<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html dir="ltr" xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>JSON-LD 1.0</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<!-- 
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
   -->



<style>
.diff { font-weight:bold; color:#0a3; }
ol.algorithm.update { margin-left: 2em; }
ol.algorithm.update>li { list-style-type: none; }
ol.algorithm.update>li>span.list-number {
  display:block;
  float: left;
  margin-left: -3.5em;
}
</style>
<style type="text/css">
/*****************************************************************
 * ReSpec CSS
 * Robin Berjon (robin at berjon dot com)
 * v0.05 - 2009-07-31
 *****************************************************************/


/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  1px solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  1px dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

code {
    color:  #ff4500;
}


/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}

/* --- TOC --- */
.toc a {
    text-decoration:    none;
}

a .secno {
    color:  #000;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}

/* --- EXAMPLES --- */
pre.example {
    border-top: 1px solid #ff4500;
    border-bottom: 1px solid #ff4500;
    padding:    1em;
    margin-top: 1em;
}

pre.example::before {
    content:    "Example";
    display:    block;
    width:      150px;
    background: #ff4500;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

/* --- EDITORIAL NOTES --- */
.issue {
    padding:    1em;
    margin: 1em 0em 0em;
    border: 1px solid #f00;
    background: #ffc;
}

.issue::before {
    content:    "Issue";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #f00;
    background: #fff;
    padding:    3px 1em;
}

.note {
    margin: 1em 0em 0em;
    padding:    1em;
    border: 2px solid #cff6d9;
    background: #e2fff0;
}

.note::before {
    content:    "Note";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #cff6d9;
    background: #fff;
    padding:    3px 1em;
}

/* --- Best Practices --- */
div.practice {
    border: solid #bebebe 1px;
    margin: 2em 1em 1em 2em;
}

span.practicelab {
    margin: 1.5em 0.5em 1em 1em;
    font-weight: bold;
    font-style: italic;
}

span.practicelab   { background: #dfffff; }

span.practicelab {
    position: relative;
    padding: 0 0.5em;
    top: -1.5em;
}

p.practicedesc {
    margin: 1.5em 0.5em 1em 1em;
}

@media screen {
    p.practicedesc {
        position: relative;
        top: -2em;
        padding: 0;
        margin: 1.5em 0.5em -1em 1em;
    }
}

/* --- SYNTAX HIGHLIGHTING --- */
pre.sh_sourceCode {
  background-color: white;
  color: black;
  font-style: normal;
  font-weight: normal;
}

pre.sh_sourceCode .sh_keyword { color: #005a9c; font-weight: bold; }           /* language keywords */
pre.sh_sourceCode .sh_type { color: #666; }                            /* basic types */
pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
pre.sh_sourceCode .sh_specialchar { color: 	#ffc0cb; font-family: monospace; }  /* e.g., \n, \t, \\ */
pre.sh_sourceCode .sh_comment { color: #A52A2A; font-style: italic; }         /* comments */
pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
pre.sh_sourceCode .sh_preproc { color: #00008B; font-weight: bold; }       /* e.g., #include, import */
pre.sh_sourceCode .sh_symbol { color: blue; }                            /* e.g., *, + */
pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: #00FFFF; }   /* TODO and FIXME */

/* Predefined variables and functions (for instance glsl) */
pre.sh_sourceCode .sh_predef_var { color: #00008B; }
pre.sh_sourceCode .sh_predef_func { color: #00008B; font-weight: bold; }

/* for OOP */
pre.sh_sourceCode .sh_classname { color: teal; }

/* line numbers (not yet implemented) */
pre.sh_sourceCode .sh_linenum { display: none; }

/* Internet related */
pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }

/* for ChangeLog and Log files */
pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: #00008B; font-weight: bold; }
pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: #006400; }

/* for Prolog, Perl... */
pre.sh_sourceCode .sh_variable { color: #006400; }

/* for LaTeX */
pre.sh_sourceCode .sh_italics { color: #006400; font-style: italic; }
pre.sh_sourceCode .sh_bold { color: #006400; font-weight: bold; }
pre.sh_sourceCode .sh_underline { color: #006400; text-decoration: underline; }
pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
pre.sh_sourceCode .sh_argument { color: #006400; }
pre.sh_sourceCode .sh_optionalargument { color: purple; }
pre.sh_sourceCode .sh_math { color: orange; }
pre.sh_sourceCode .sh_bibtex { color: blue; }

/* for diffs */
pre.sh_sourceCode .sh_oldfile { color: orange; }
pre.sh_sourceCode .sh_newfile { color: #006400; }
pre.sh_sourceCode .sh_difflines { color: blue; }

/* for css */
pre.sh_sourceCode .sh_selector { color: purple; }
pre.sh_sourceCode .sh_property { color: blue; }
pre.sh_sourceCode .sh_value { color: #006400; font-style: italic; }

/* other */
pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
pre.sh_sourceCode .sh_paren { color: red; }
pre.sh_sourceCode .sh_attribute { color: #006400; }

</style><style type="text/css">ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }

</style><link href="http://www.w3.org/StyleSheets/TR/w3c-unofficial" rel="stylesheet" type="text/css" charset="utf-8" /><style type='text/css'>
.diff-old-a {
  font-size: smaller;
  color: red;
}

.diff-new { background-color: yellow; }
.diff-chg { background-color: lime; }
.diff-new:before,
.diff-new:after
    { content: "\2191" }
.diff-chg:before, .diff-chg:after
    { content: "\2195" }
.diff-old { text-decoration: line-through; background-color: #FBB; }
.diff-old:before,
.diff-old:after
    { content: "\2193" }
:focus { border: thin red solid}
</style>
</head>


<body style="display: inherit; ">
<div class="head">
<p>
</p>
<h1 class="title" id="title">
JSON-LD
<del class="diff-old">Syntax
</del>
1.0
</h1>
<h2 id="subtitle">
A
Context-based
JSON
Serialization
for
Linking
Data
</h2>
<h2 id="unofficial-draft-12-september-2011">
Unofficial
Draft
<del class="diff-old">16
October
</del>
<ins class="diff-chg">12
September
</ins>
2011
</h2>
<dl>
<dt>
<del class="diff-old">Editor:
</del>
<ins class="diff-chg">Editors:
</ins>
</dt>
<dd>
<a href="http://manu.sporny.org/">
Manu
Sporny
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</dd>
<del class="diff-old">Authors:
</del>
<dd>
<a href="http://greggkellogg.net/">
<ins class="diff-new">Gregg
Kellogg
</ins></a>,<ins class="diff-new">
Kellogg
Associates
</ins></dd>
<dd>
<a href="http://digitalbazaar.com/">
<del class="diff-old">Manu
Sporny
</del>
<ins class="diff-chg">Dave
Longley
</ins>
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</dd>
<dt>
<ins class="diff-new">Authors:
</ins></dt>
<dd>
<a href="http://digitalbazaar.com/">
<del class="diff-old">Dave
Longley
</del>
<ins class="diff-chg">Manu
Sporny
</ins>
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</dd>
<dd>
<a href="http://greggkellogg.net/">
Gregg
Kellogg
</a>,
Kellogg
Associates
</dd>
<dd>
<a href="http://digitalbazaar.com/">
<ins class="diff-new">Dave
Longley
</ins></a>,<a href="http://digitalbazaar.com/"><ins class="diff-new">
Digital
Bazaar
</ins></a></dd><dd>
<a href="http://webbackplane.com/">
Mark
Birbeck
</a>,
<a href="http://webbackplane.com/">
Backplane
Ltd.
</a>
</dd>
</dl>
<p>
This
document
is
also
available
in
this
non-normative
format:
<a href="diff-20110817.html">
diff
to
previous
version
</a>.
</p>
<p class="copyright">
This
document
is
licensed
under
a
<a class="subfoot" href="http://creativecommons.org/licenses/by/3.0/" rel="license">
Creative
Commons
Attribution
3.0
License
</a>.
</p>
<hr />
</div>
<div id="abstract" class="introductory section">
<h2>
Abstract
</h2>
<p>
JSON
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
]
has
proven
to
be
a
highly
useful
object
serialization
and
messaging
format.
In
an
attempt
to
harmonize
the
representation
of
Linked
Data
in
JSON,
this
specification
outlines
a
common
JSON
representation
format
for
expressing
directed
graphs;
mixing
both
Linked
Data
and
non-Linked
Data
in
a
single
document.
</p>
</div>
<div id="sotd" class="introductory section">
<h2>
Status
of
This
Document
</h2>
<p>
This
document
is
merely
a
public
working
draft
of
a
potential
specification.
It
has
no
official
standing
of
any
kind
and
does
not
represent
the
support
or
consensus
of
any
standards
organisation.
</p>
<p>
This
document
is
an
experimental
work
in
progress.
</p>
</div>
<div id="toc" class="section">
<h2 class="introductory">
Table
of
Contents
</h2>
<ul class="toc">
<li class="tocline">
<a href="#introduction" class="tocxref">
<span class="secno">
1.
</span>
Introduction
</a>
<ul class="toc">
<li class="tocline">
<a href="#how-to-read-this-document" class="tocxref">
<span class="secno">
1.1
</span>
How
to
Read
this
Document
</a>
</li>
<li class="tocline">
<a href="#contributing" class="tocxref">
<span class="secno">
1.2
</span>
Contributing
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#design" class="tocxref">
<span class="secno">
2.
</span>
Design
</a>
<ul class="toc">
<li class="tocline">
<a href="#goals-and-rationale" class="tocxref">
<span class="secno">
2.1
</span>
Goals
and
Rationale
</a>
</li>
<li class="tocline">
<a href="#linked-data" class="tocxref">
<span class="secno">
2.2
</span>
Linked
Data
</a>
</li>
<li class="tocline">
<a href="#linking-data" class="tocxref">
<span class="secno">
2.3
</span>
Linking
Data
</a>
</li>
<li class="tocline">
<a href="#the-context" class="tocxref">
<span class="secno">
2.4
</span>
The
Context
</a>
</li>
<li class="tocline">
<a href="#from-json-to-json-ld" class="tocxref">
<span class="secno">
2.5
</span>
From
JSON
to
JSON-LD
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#basic-concepts" class="tocxref">
<span class="secno">
3.
</span>
Basic
Concepts
</a>
<ul class="toc">
<li class="tocline">
<a href="#iris" class="tocxref">
<span class="secno">
3.1
</span>
IRIs
</a>
</li>
<li class="tocline">
<a href="#identifying-the-subject" class="tocxref">
<span class="secno">
3.2
</span>
Identifying
the
Subject
</a>
</li>
<li class="tocline">
<a href="#specifying-the-type" class="tocxref">
<span class="secno">
3.3
</span>
Specifying
the
Type
</a>
</li>
<li class="tocline">
<a href="#strings" class="tocxref">
<span class="secno">
3.4
</span>
Strings
</a>
</li>
<li class="tocline">
<a href="#string-internationalization" class="tocxref">
<span class="secno">
3.5
</span>
String
Internationalization
</a>
</li>
<li class="tocline">
<a href="#datatypes" class="tocxref">
<span class="secno">
3.6
</span>
Datatypes
</a>
</li>
<li class="tocline">
<a href="#multiple-objects-for-a-single-property" class="tocxref">
<span class="secno">
3.7
</span>
Multiple
Objects
for
a
Single
Property
</a>
</li>
<li class="tocline">
<a href="#multiple-typed-literals-for-a-single-property" class="tocxref">
<span class="secno">
3.8
</span>
Multiple
Typed
Literals
for
a
Single
Property
</a>
</li>
<li class="tocline">
<a href="#expansion" class="tocxref">
<span class="secno">
3.9
</span>
Expansion
</a>
</li>
<li class="tocline">
<a href="#compaction" class="tocxref">
<span class="secno">
3.10
</span>
Compaction
</a>
</li>
<li class="tocline">
<a href="#framing" class="tocxref">
<span class="secno">
3.11
</span>
Framing
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#advanced-concepts" class="tocxref">
<span class="secno">
4.
</span>
Advanced
Concepts
</a>
<ul class="toc">
<li class="tocline">
<del class="diff-old">4.1
External
Contexts
</del>
<a href="#vocabulary-prefixes" class="tocxref">
<span class="secno">
<del class="diff-old">4.2
</del>
<ins class="diff-chg">4.1
</ins>
</span>
Vocabulary
Prefixes
</a>
</li>
<li class="tocline">
<a href="#automatic-typing" class="tocxref">
<span class="secno">
<del class="diff-old">4.3
</del>
<ins class="diff-chg">4.2
</ins>
</span>
Automatic
Typing
</a>
</li>
<li class="tocline">
<a href="#type-coercion" class="tocxref">
<span class="secno">
<del class="diff-old">4.4
</del>
<ins class="diff-chg">4.3
</ins>
</span>
Type
Coercion
</a>
</li>
<li class="tocline">
<a href="#chaining" class="tocxref">
<span class="secno">
<del class="diff-old">4.5
</del>
<ins class="diff-chg">4.4
</ins>
</span>
Chaining
</a>
</li>
<li class="tocline">
<a href="#identifying-unlabeled-nodes" class="tocxref">
<span class="secno">
<del class="diff-old">4.6
</del>
<ins class="diff-chg">4.5
</ins>
</span>
Identifying
Unlabeled
Nodes
</a>
</li>
<li class="tocline">
<a href="#aliasing-keywords" class="tocxref">
<span class="secno">
<del class="diff-old">4.7
</del>
<ins class="diff-chg">4.6
</ins>
</span>
Aliasing
Keywords
</a>
</li>
<li class="tocline">
<a href="#normalization" class="tocxref">
<span class="secno">
<del class="diff-old">4.8
</del>
<ins class="diff-chg">4.7
</ins>
</span>
Normalization
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#the-application-programming-interface" class="tocxref">
<span class="secno">
<ins class="diff-chg">5.
</ins></span><ins class="diff-chg">
The
Application
Programming
Interface
</ins></a><ul class="toc"><li class="tocline"><a href="#jsonldprocessor" class="tocxref"><span class="secno"><ins class="diff-chg">
5.1
</ins></span><ins class="diff-chg">
JsonLdProcessor
</ins></a><ul class="toc"><li class="tocline"><a href="#methods" class="tocxref"><span class="secno"><ins class="diff-chg">
5.1.1
</ins></span><ins class="diff-chg">
Methods
</ins></a></li></ul></li><li class="tocline"><a href="#jsonldtriplecallback" class="tocxref"><span class="secno"><ins class="diff-chg">
5.2
</ins></span><ins class="diff-chg">
JsonLdTripleCallback
</ins></a><ul class="toc"><li class="tocline"><a href="#methods-1" class="tocxref"><span class="secno"><ins class="diff-chg">
5.2.1
</ins></span><ins class="diff-chg">
Methods
</ins></a></li></ul></li></ul></li><li class="tocline"><a href="#algorithms" class="tocxref"><span class="secno"><ins class="diff-chg">
6.
</ins></span><ins class="diff-chg">
Algorithms
</ins></a><ul class="toc"><li class="tocline"><a href="#syntax-tokens-and-keywords" class="tocxref"><span class="secno"><ins class="diff-chg">
6.1
</ins></span><ins class="diff-chg">
Syntax
Tokens
and
Keywords
</ins></a></li><li class="tocline"><a href="#algorithm-terms" class="tocxref"><span class="secno"><ins class="diff-chg">
6.2
</ins></span><ins class="diff-chg">
Algorithm
Terms
</ins></a></li><li class="tocline"><a href="#context-1" class="tocxref"><span class="secno"><ins class="diff-chg">
6.3
</ins></span><ins class="diff-chg">
Context
</ins></a><ul class="toc"><li class="tocline"><a href="#coerce" class="tocxref"><span class="secno"><ins class="diff-chg">
6.3.1
</ins></span><ins class="diff-chg">
Coerce
</ins></a></li><li class="tocline"><a href="#initial-context" class="tocxref"><span class="secno"><ins class="diff-chg">
6.3.2
</ins></span><ins class="diff-chg">
Initial
Context
</ins></a></li></ul></li><li class="tocline"><a href="#iri-expansion" class="tocxref"><span class="secno"><ins class="diff-chg">
6.4
</ins></span><ins class="diff-chg">
IRI
Expansion
</ins></a></li><li class="tocline"><a href="#iri-compaction" class="tocxref"><span class="secno"><ins class="diff-chg">
6.5
</ins></span><ins class="diff-chg">
IRI
Compaction
</ins></a></li><li class="tocline"><a href="#value-expansion" class="tocxref"><span class="secno"><ins class="diff-chg">
6.6
</ins></span><ins class="diff-chg">
Value
Expansion
</ins></a></li><li class="tocline"><a href="#value-compaction" class="tocxref"><span class="secno"><ins class="diff-chg">
6.7
</ins></span><ins class="diff-chg">
Value
Compaction
</ins></a></li><li class="tocline"><a href="#expansion-1" class="tocxref"><span class="secno"><ins class="diff-chg">
6.8
</ins></span><ins class="diff-chg">
Expansion
</ins></a><ul class="toc"><li class="tocline"><a href="#expansion-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.8.1
</ins></span><ins class="diff-chg">
Expansion
Algorithm
</ins></a></li></ul></li><li class="tocline"><a href="#compaction-1" class="tocxref"><span class="secno"><ins class="diff-chg">
6.9
</ins></span><ins class="diff-chg">
Compaction
</ins></a><ul class="toc"><li class="tocline"><a href="#compaction-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.9.1
</ins></span><ins class="diff-chg">
Compaction
Algorithm
</ins></a></li></ul></li><li class="tocline"><a href="#framing-1" class="tocxref"><span class="secno"><ins class="diff-chg">
6.10
</ins></span><ins class="diff-chg">
Framing
</ins></a><ul class="toc"><li class="tocline"><a href="#framing-algorithm-terms" class="tocxref"><span class="secno"><ins class="diff-chg">
6.10.1
</ins></span><ins class="diff-chg">
Framing
Algorithm
Terms
</ins></a></li><li class="tocline"><a href="#framing-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.10.2
</ins></span><ins class="diff-chg">
Framing
Algorithm
</ins></a></li></ul></li><li class="tocline"><a href="#normalization-1" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11
</ins></span><ins class="diff-chg">
Normalization
</ins></a><ul class="toc"><li class="tocline"><a href="#normalization-algorithm-terms" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.1
</ins></span><ins class="diff-chg">
Normalization
Algorithm
Terms
</ins></a></li><li class="tocline"><a href="#normalization-state" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.2
</ins></span><ins class="diff-chg">
Normalization
State
</ins></a></li><li class="tocline"><a href="#normalization-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.3
</ins></span><ins class="diff-chg">
Normalization
Algorithm
</ins></a></li><li class="tocline"><a href="#node-relabeling-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.4
</ins></span><ins class="diff-chg">
Node
Relabeling
Algorithm
</ins></a></li><li class="tocline"><a href="#deterministic-labeling-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.5
</ins></span><ins class="diff-chg">
Deterministic
Labeling
Algorithm
</ins></a></li><li class="tocline"><a href="#shallow-comparison-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.6
</ins></span><ins class="diff-chg">
Shallow
Comparison
Algorithm
</ins></a></li><li class="tocline"><a href="#object-comparison-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.7
</ins></span><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></a></li><li class="tocline"><a href="#deep-comparison-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.8
</ins></span><ins class="diff-chg">
Deep
Comparison
Algorithm
</ins></a></li><li class="tocline"><a href="#node-serialization-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.9
</ins></span><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></a></li><li class="tocline"><a href="#serialization-label-generation-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.10
</ins></span><ins class="diff-chg">
Serialization
Label
Generation
Algorithm
</ins></a></li><li class="tocline"><a href="#combinatorial-serialization-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.11
</ins></span><ins class="diff-chg">
Combinatorial
Serialization
Algorithm
</ins></a></li><li class="tocline"><a href="#serialization-comparison-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.12
</ins></span><ins class="diff-chg">
Serialization
Comparison
Algorithm
</ins></a></li><li class="tocline"><a href="#mapping-serialization-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.13
</ins></span><ins class="diff-chg">
Mapping
Serialization
Algorithm
</ins></a></li><li class="tocline"><a href="#label-serialization-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.11.14
</ins></span><ins class="diff-chg">
Label
Serialization
Algorithm
</ins></a></li></ul></li><li class="tocline"><a href="#data-round-tripping" class="tocxref"><span class="secno"><ins class="diff-chg">
6.12
</ins></span><ins class="diff-chg">
Data
Round
Tripping
</ins></a></li><li class="tocline"><a href="#rdf-conversion" class="tocxref"><span class="secno"><ins class="diff-chg">
6.13
</ins></span><ins class="diff-chg">
RDF
Conversion
</ins></a><ul class="toc"><li class="tocline"><a href="#overview" class="tocxref"><span class="secno"><ins class="diff-chg">
6.13.1
</ins></span><ins class="diff-chg">
Overview
</ins></a></li><li class="tocline"><a href="#rdf-conversion-algorithm-terms" class="tocxref"><span class="secno"><ins class="diff-chg">
6.13.2
</ins></span><ins class="diff-chg">
RDF
Conversion
Algorithm
Terms
</ins></a></li><li class="tocline"><a href="#rdf-conversion-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
6.13.3
</ins></span><ins class="diff-chg">
RDF
Conversion
Algorithm
</ins></a></li></ul></li></ul></li><li class="tocline"><a href="#experimental-concepts" class="tocxref">
<span class="secno">
A.
</span>
<ins class="diff-new">Experimental
Concepts
</ins></a><ul class="toc"><li class="tocline"><a href="#disjoint-graphs" class="tocxref"><span class="secno"><ins class="diff-new">
A.1
</ins></span><ins class="diff-new">
Disjoint
Graphs
</ins></a></li><li class="tocline"><a href="#lists" class="tocxref"><span class="secno"><ins class="diff-new">
A.2
</ins></span><ins class="diff-new">
Lists
</ins></a><ul class="toc"><li class="tocline"><a href="#expansion-2" class="tocxref"><span class="secno"><ins class="diff-new">
A.2.1
</ins></span><ins class="diff-new">
Expansion
</ins></a></li><li class="tocline"><a href="#normalization-2" class="tocxref"><span class="secno"><ins class="diff-new">
A.2.2
</ins></span><ins class="diff-new">
Normalization
</ins></a></li><li class="tocline"><a href="#rdf-conversion-1" class="tocxref"><span class="secno"><ins class="diff-new">
A.2.3
</ins></span><ins class="diff-new">
RDF
Conversion
</ins></a></li></ul></li></ul></li><li class="tocline"><a href="#markup-examples" class="tocxref"><span class="secno"><ins class="diff-new">
B.
</ins></span>
Markup
Examples
</a>
<ul class="toc">
<li class="tocline">
<a href="#rdfa" class="tocxref">
<span class="secno">
<del class="diff-old">A.1
</del>
<ins class="diff-chg">B.1
</ins>
</span>
RDFa
</a>
</li>
<li class="tocline">
<a href="#microformats" class="tocxref">
<span class="secno">
<del class="diff-old">A.2
</del>
<ins class="diff-chg">B.2
</ins>
</span>
Microformats
</a>
</li>
<li class="tocline">
<a href="#microdata" class="tocxref">
<span class="secno">
<del class="diff-old">A.3
</del>
<ins class="diff-chg">B.3
</ins>
</span>
Microdata
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#mashing-up-vocabularies" class="tocxref">
<span class="secno">
<del class="diff-old">B.
</del>
<ins class="diff-chg">C.
</ins>
</span>
Mashing
Up
Vocabularies
</a>
</li>
<li class="tocline">
<a href="#iana-considerations" class="tocxref">
<span class="secno">
<del class="diff-old">C.
</del>
<ins class="diff-chg">D.
</ins>
</span>
IANA
Considerations
</a>
</li>
<li class="tocline">
<a href="#acknowledgements" class="tocxref">
<span class="secno">
<del class="diff-old">D.
</del>
<ins class="diff-chg">E.
</ins>
</span>
Acknowledgements
</a>
</li>
<li class="tocline">
<a href="#references" class="tocxref">
<span class="secno">
<del class="diff-old">E.
</del>
<ins class="diff-chg">F.
</ins>
</span>
References
</a>
<ul class="toc">
<li class="tocline">
<a href="#normative-references" class="tocxref">
<span class="secno">
<del class="diff-old">E.1
</del>
<ins class="diff-chg">F.1
</ins>
</span>
Normative
references
</a>
</li>
<li class="tocline">
<a href="#informative-references" class="tocxref">
<span class="secno">
<del class="diff-old">E.2
</del>
<ins class="diff-chg">F.2
</ins>
</span>
Informative
references
</a>
</li>
</ul>
</li>
</ul>
</div>
<div id="introduction" class="section">
<h2>
<span class="secno">
1.
</span>
Introduction
</h2>
<p>
JSON,
as
specified
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
],
is
a
simple
language
for
representing
data
on
the
Web.
Linked
Data
is
a
technique
for
creating
a
graph
of
interlinked
data
across
different
documents
or
Web
sites.
Data
entities
are
described
using
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
s,
which
are
typically
dereferencable
and
thus
may
be
used
to
find
more
information
about
an
entity,
creating
a
<del class="diff-old">&quot;Web
</del>
<ins class="diff-chg">"Web
</ins>
of
<del class="diff-old">Knowledge&quot;.
</del>
<ins class="diff-chg">Knowledge".
</ins>
JSON-LD
is
intended
to
be
a
simple
publishing
method
for
expressing
not
only
Linked
Data
in
JSON,
but
also
for
adding
semantics
to
existing
JSON.
</p>
<p>
JSON-LD
is
designed
as
a
light-weight
syntax
that
can
be
used
to
express
Linked
Data.
It
is
primarily
intended
to
be
a
way
to
use
Linked
Data
in
Javascript
and
other
Web-based
programming
environments.
It
is
also
useful
when
building
interoperable
Web
services
and
when
storing
Linked
Data
in
JSON-based
document
storage
engines.
It
is
practical
and
designed
to
be
as
simple
as
possible,
utilizing
the
large
number
of
JSON
parsers
and
libraries
available
today.
It
is
designed
to
be
able
to
express
key-value
pairs,
RDF
data,
RDFa
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">
RDFA-CORE
</a>
</cite>
]
data,
Microformats
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-MICROFORMATS">
MICROFORMATS
</a>
</cite>
]
data,
and
Microdata
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-MICRODATA">
MICRODATA
</a>
</cite>
].
That
is,
it
supports
every
major
Web-based
structured
data
model
in
use
today.
</p>
<p>
The
syntax
does
not
necessarily
require
applications
to
change
their
JSON,
but
allows
to
easily
add
meaning
by
adding
context
in
a
way
that
is
either
in-band
or
out-of-band.
The
syntax
is
designed
to
not
disturb
already
deployed
systems
running
on
JSON,
but
provide
a
smooth
upgrade
path
from
JSON
to
JSON
with
added
semantics.
Finally,
the
format
is
intended
to
be
easy
to
parse,
efficient
to
generate,
<del class="diff-old">convertible
to
RDF
in
one
pass,
</del>
<ins class="diff-chg">stream-based
and
document-based
processing
compatible,
</ins>
and
require
a
very
small
memory
footprint
in
order
to
operate.
</p>
<div id="how-to-read-this-document" class="section">
<h3>
<span class="secno">
1.1
</span>
How
to
Read
this
Document
</h3>
<p>
This
document
is
a
detailed
specification
for
a
serialization
of
Linked
Data
in
JSON.
The
document
is
primarily
intended
for
the
following
audiences:
</p>
<ul>
<li>
Web
developers
that
want
to
understand
the
design
decisions
and
language
syntax
for
JSON-LD.
</li>
<li>
Software
developers
that
want
to
encode
Microformats,
RDFa,
or
Microdata
in
a
way
that
is
cross-language
compatible
via
JSON.
</li>
<li>
Software
developers
that
want
to
implement
processors
and
APIs
for
JSON-LD.
</li>
</ul>
<p>
To
understand
the
basics
in
this
specification
you
must
first
be
familiar
with
JSON,
which
is
detailed
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
].
To
understand
the
API
and
how
it
is
intended
to
operate
in
a
programming
environment,
it
is
useful
to
have
working
knowledge
of
the
JavaScript
programming
language
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-ECMA-262">
ECMA-262
</a>
</cite>
]
and
WebIDL
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-WEBIDL">
WEBIDL
</a>
</cite>
].
To
understand
how
JSON-LD
maps
to
RDF,
it
is
helpful
to
be
familiar
with
the
basic
RDF
concepts
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">
RDF-CONCEPTS
</a>
</cite>
].
</p>
<p>
Examples
may
contain
references
to
existing
vocabularies
and
use
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>
es
to
refer
to
Web
Vocabularies.
The
following
is
a
list
of
all
vocabularies
and
their
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>
abbreviations,
as
used
in
this
document:
</p>
<ul>
<li>
The
<a href="http://purl.org/dc/terms/">
Dublin
Core
</a>
vocabulary
(abbreviation:
<code>
dc
</code>,
e.g.,
<code>
dc:title
</code>
)
</li>
<li>
The
<a href="http://xmlns.com/foaf/0.1/">
Friend
of
a
Friend
</a>
vocabulary
(abbreviation:
<code>
foaf
</code>,
e.g.,
<code>
foaf:knows
</code>
)
</li>
<li>
The
<a href="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
RDF
</a>
vocabulary
(abbreviation:
<code>
rdf
</code>,
e.g.,
<code>
rdf:type
</code>
)
</li>
<li>
The
<a href="http://www.w3.org/2001/XMLSchema#">
XSD
</a>
vocabulary
(abbreviation:
<code>
xsd
</code>,
e.g.,
<code>
xsd:integer
</code>
)
</li>
</ul>
<p>
JSON
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
]
defines
several
terms
which
are
used
throughout
this
document:
</p>
<dl>
<dt>
<dfn title="JSON_Object" id="dfn-json_object">
JSON
Object
</dfn>
</dt>
<dd>
An
object
structure
is
represented
as
a
pair
of
curly
brackets
surrounding
zero
or
more
name/value
pairs
(or
members).
A
name
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>.
A
single
colon
comes
after
each
name,
separating
the
name
from
the
value.
A
single
comma
separates
a
value
from
a
following
name.
The
names
within
an
object
<em class="rfc2119" title="should">
should
</em>
be
unique.
</dd>
<dt>
<dfn title="array" id="dfn-array">
array
</dfn>
</dt>
<dd>
An
array
is
an
ordered
collection
of
values.
An
array
structure
is
represented
as
square
brackets
surrounding
zero
or
more
values
(or
elements).
Elements
are
separated
by
commas.
Within
JSON-LD,
array
order
is
not
preserved
by
default,
unless
specific
markup
is
provided
(see
<a href="#lists">
Lists
</a>
).
This
is
because
the
basic
data
model
of
JSON-LD
is
a
directed
<a class="tref" title="graph">
graph
</a>,
which
is
inherently
unordered.
</dd>
<dt>
<dfn title="string" id="dfn-string">
string
</dfn>
</dt>
<dd>
A
string
is
a
sequence
of
zero
or
more
Unicode
characters,
wrapped
in
double
quotes,
using
backslash
escapes.
A
character
is
represented
as
a
single
character
string.
</dd>
<dt>
<dfn title="number" id="dfn-number">
number
</dfn>
</dt>
<dd>
A
number
is
is
similar
to
that
used
in
most
programming
languages,
except
that
the
octal
and
hexadecimal
formats
are
not
used
and
that
leading
zeros
are
not
allowed.
</dd>
<dt>
<dfn title="true" id="dfn-true">
true
</dfn>
and
<dfn title="false" id="dfn-false">
false
</dfn>
</dt>
<dd>
Boolean
values.
</dd>
<dt>
<dfn title="null" id="dfn-null">
null
</dfn>
</dt>
<dd>
The
use
of
the
<em>
null
</em>
value
is
undefined
within
JSON-LD.
<div class="issue">
Supporting
<em>
null
</em>
in
JSON-LD
might
have
a
number
of
advantages
and
should
be
evaluated.
This
is
currently
an
<a href="https://github.com/json-ld/json-ld.org/issues/11">
open
issue
</a>.
</div>
</dd>
</dl>
<p>
</p>
</div>
<div id="contributing" class="section">
<h3>
<span class="secno">
1.2
</span>
Contributing
</h3>
<p>
There
are
a
number
of
ways
that
one
may
participate
in
the
development
of
this
specification:
</p>
<ul>
<li>
Technical
discussion
typically
occurs
on
the
public
mailing
list:
<a href="http://lists.w3.org/Archives/Public/public-linked-json/">
public-linked-json@w3.org
</a>
</li>
<li>
<a href="http://json-ld.org/minutes/">
Public
teleconferences
</a>
are
held
on
Tuesdays
at
1500UTC
on
the
second
and
fourth
week
of
each
month.
</li>
<li>
Specification
bugs
and
issues
should
be
reported
in
the
<a href="https://github.com/json-ld/json-ld.org/issues">
issue
tracker
</a>.
</li>
<li>
<a href="https://github.com/json-ld/json-ld.org/tree/main/spec">
Source
code
</a>
for
the
specification
can
be
found
on
Github.
</li>
<li>
The
<a href="http://webchat.freenode.net/?channels=#json-ld">
#json-ld
</a>
IRC
channel
is
available
for
real-time
discussion
on
irc.freenode.net.
</li>
</ul>
</div>
</div>
<div id="design" class="section">
<h2>
<span class="secno">
2.
</span>
Design
</h2>
<p>
The
following
section
outlines
the
design
goals
and
rationale
behind
the
JSON-LD
markup
language.
</p>
<div id="goals-and-rationale" class="section">
<h3>
<span class="secno">
2.1
</span>
Goals
and
Rationale
</h3>
<p>
A
number
of
design
considerations
were
explored
during
the
creation
of
this
markup
language:
</p>
<dl>
<dt>
Simplicity
</dt>
<dd>
Developers
need
only
know
JSON
and
three
keywords
to
use
the
basic
functionality
in
JSON-LD.
No
extra
processors
or
software
libraries
are
necessary
to
use
JSON-LD
in
its
most
basic
form.
The
language
attempts
to
ensure
that
developers
have
an
easy
learning
curve.
</dd>
<dt>
Compatibility
</dt>
<dd>
The
JSON-LD
markup
must
be
100%
compatible
with
JSON.
This
ensures
that
all
of
the
standard
JSON
libraries
work
seamlessly
with
JSON-LD
documents.
</dd>
<dt>
Expressiveness
</dt>
<dd>
The
syntax
must
be
able
to
express
directed
graphs,
which
have
been
proven
to
be
able
to
simply
express
almost
every
real
world
data
model.
</dd>
<dt>
Terseness
</dt>
<dd>
The
JSON-LD
syntax
must
be
very
terse
and
human
readable,
requiring
as
little
as
possible
effort
from
the
developer.
</dd>
<dt>
Zero
Edits,
most
of
the
time
</dt>
<dd>
JSON-LD
provides
a
mechanism
that
allows
developers
to
specify
context
in
a
way
that
is
out-of-band.
This
allows
organizations
that
have
already
deployed
large
JSON-based
infrastructure
to
add
meaning
to
their
JSON
documents
in
a
way
that
is
not
disruptive
to
their
day-to-day
operations
and
is
transparent
to
their
current
customers.
At
times,
mapping
JSON
to
a
graph
representation
can
become
difficult.
In
these
instances,
rather
than
having
JSON-LD
support
esoteric
markup,
we
chose
not
to
support
the
use
case
and
support
a
simplified
syntax
instead.
So,
while
Zero
Edits
is
a
goal,
it
is
not
always
possible
without
adding
great
complexity
to
the
language.
</dd>
<dt>
<del class="diff-old">One-pass
Processing
</del>
<ins class="diff-chg">Streaming
</ins>
</dt>
<dd>
<del class="diff-old">JSON-LD
</del>
<ins class="diff-chg">The
format
</ins>
supports
<del class="diff-old">one-pass
processing,
which
results
in
a
very
small
memory
footprint
when
processing
documents.
For
example,
to
convert
a
JSON-LD
document
into
an
RDF
document
of
any
kind,
only
one
pass
is
required
over
the
data.
</del>
<ins class="diff-chg">both
document-based
and
stream-based
processing.
</ins>
</dd>
</dl>
</div>
<div id="linked-data" class="section">
<h3>
<span class="secno">
2.2
</span>
Linked
Data
</h3>
<p>
The
following
definition
for
<a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">
Linked
Data
</a>
is
the
one
that
will
be
used
for
this
specification.
</p>
<ol>
<li>
<dfn title="Linked_Data" id="dfn-linked_data">
Linked
Data
</dfn>
is
a
set
of
documents,
each
containing
a
representation
of
a
linked
data
graph.
</li>
<li>
A
<dfn title="linked_data_graph" id="dfn-linked_data_graph">
linked
data
graph
</dfn>
is
an
unordered
labeled
directed
graph,
where
nodes
are
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>
s
or
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
s,
and
edges
are
properties.
</li>
<li>
A
<dfn title="subject" id="dfn-subject">
subject
</dfn>
is
any
node
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
with
at
least
one
outgoing
edge.
</li>
<li>
A
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>
<em class="rfc2119" title="should">
should
</em>
be
labeled
with
an
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
(an
Internationalized
Resource
Identifier
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3987">
RFC3987
</a>
</cite>
]).
</li>
<li>
An
<dfn title="object" id="dfn-object">
object
</dfn>
is
a
node
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
with
at
least
one
incoming
edge.
</li>
<li>
An
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
<em class="rfc2119" title="may">
may
</em>
be
labeled
with
an
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>.
</li>
<li>
An
object
<em class="rfc2119" title="may">
may
</em>
be
a
<dfn title="subject" id="dfn-subject-1">
subject
</dfn>
and
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
at
the
same
time.
</li>
<li>
A
<dfn title="property" id="dfn-property">
property
</dfn>
is
an
edge
of
the
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>.
</li>
<li>
A
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>
<em class="rfc2119" title="should">
should
</em>
be
labeled
with
an
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>.
</li>
<li>
An
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
that
is
a
label
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
<em class="rfc2119" title="should">
should
</em>
be
dereferencable
to
a
<a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">
Linked
Data
</a>
document
describing
the
labeled
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>,
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
or
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>.
</li>
<li>
A
<dfn title="literal" id="dfn-literal">
literal
</dfn>
is
an
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
with
a
label
that
is
not
an
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
</li>
</ol>
<p>
Note
that
the
definition
for
<a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">
Linked
Data
</a>
above
is
silent
on
the
topic
of
unlabeled
nodes.
Unlabeled
nodes
are
not
considered
<a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">
Linked
Data
</a>.
However,
this
specification
allows
for
the
expression
of
unlabled
nodes,
as
most
graph-based
data
sets
on
the
Web
contain
a
number
of
associated
nodes
that
are
not
named
and
thus
are
not
directly
de-referenceable.
</p>
</div>
<div id="linking-data" class="section">
<h3>
<span class="secno">
2.3
</span>
Linking
Data
</h3>
<p>
An
Internationalized
Resource
Identifier
(
<dfn title="IRI" id="dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</dfn>
),
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3987">
RFC3987
</a>
</cite>
],
is
a
mechanism
for
representing
unique
identifiers
on
the
web.
In
<a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">
Linked
Data
</a>,
an
IRI
is
commonly
used
for
expressing
a
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>,
a
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>
or
an
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>.
</p>
<p>
JSON-LD
defines
a
mechanism
to
map
JSON
terms,
i.e.,
keys
and
values,
to
IRIs.
This
does
not
mean
that
JSON-LD
requires
every
key
or
value
to
be
an
IRI,
but
rather
ensures
that
keys
and
values
can
be
mapped
to
IRIs
if
the
developer
desires
to
transform
their
data
into
Linked
Data.
There
are
a
few
techniques
that
can
ensure
that
developers
will
generate
good
Linked
Data
for
the
Web.
JSON-LD
formalizes
those
techniques.
</p>
<p>
We
will
be
using
the
following
JSON
markup
as
the
example
for
the
rest
of
this
section:
</p>
<del class="diff-old">{
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;,
  &quot;avatar&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/",
  "avatar": "http://twitter.com/account/profile_image/manusporny"
</ins>
}
</pre>
</div>
<div id="the-context" class="section">
<h3>
<span class="secno">
2.4
</span>
The
Context
</h3>
<p>
In
JSON-LD,
a
context
is
used
to
map
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s,
i.e.,
keys
and
values
in
an
JSON
document,
to
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
s.
A
<dfn title="term" id="dfn-term">
term
</dfn>
is
a
short
word
that
<em class="rfc2119" title="may">
may
</em>
be
expanded
to
an
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>.
The
Web
uses
IRIs
for
unambiguous
identification.
The
idea
is
that
these
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
mean
something
that
may
be
of
use
to
other
developers
and
that
it
is
useful
to
give
them
an
unambiguous
identifier.
That
is,
it
is
useful
for
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
to
expand
to
IRIs
so
that
developers
don't
accidentally
step
on
each
other's
Web
Vocabulary
terms.
For
example,
the
term
<code>
name
</code>
may
map
directly
to
the
IRI
<code>
http://xmlns.com/foaf/0.1/name
</code>.
This
allows
JSON-LD
documents
to
be
constructed
using
the
common
JSON
practice
of
simple
name/value
pairs
while
ensuring
that
the
data
is
useful
outside
of
the
page,
API
or
database
in
which
it
resides.
</p>
<p>
These
Linked
Data
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
are
typically
collected
in
a
context
document
that
would
look
something
like
this:
</p>
<del class="diff-old">{
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
    &quot;avatar&quot;: &quot;http://xmlns.com/foaf/0.1/avatar&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": "http://xmlns.com/foaf/0.1/homepage",
    "avatar": "http://xmlns.com/foaf/0.1/avatar"
</ins>
}
</pre>
<p>
This
context
document
can
then
be
used
in
an
JSON-LD
document
by
adding
a
single
line.
The
JSON
markup
as
shown
in
the
previous
section
could
be
changed
as
follows
to
link
to
the
context
document:
</p>
<del class="diff-old">{
  
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;,
  &quot;avatar&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>  <span class="diff">"@context": "http://example.org/json-ld-contexts/person",</span><ins class="diff-chg">
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/",
  "avatar": "http://twitter.com/account/profile_image/manusporny"
</ins>
}
</pre>
<p>
The
<del class="diff-old">additions
</del>
<ins class="diff-chg">addition
</ins>
above
<del class="diff-old">transform
</del>
<ins class="diff-chg">transforms
</ins>
the
previous
JSON
document
into
a
JSON
document
with
added
semantics
because
the
<code>
@context
</code>
specifies
how
the
<strong>
name
</strong>,
<strong>
homepage
</strong>,
and
<strong>
avatar
</strong>
terms
map
to
IRIs.
Mapping
those
keys
to
IRIs
gives
the
data
global
context.
If
two
developers
use
the
same
IRI
to
describe
a
property,
they
are
more
than
likely
expressing
the
same
concept.
This
allows
both
developers
to
re-use
each
others
data
without
having
to
agree
to
how
their
data
will
inter-operate
on
a
site-by-site
basis.
Contexts
may
also
contain
datatype
information
for
certain
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
as
well
as
other
processing
instructions
for
the
JSON-LD
processor.
</p>
<p>
Contexts
may
be
specified
in-line.
This
ensures
that
JSON-LD
documents
can
be
processed
when
a
JSON-LD
processor
does
not
have
access
to
the
Web.
</p>
<del class="diff-old">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
    &quot;avatar&quot;: &quot;http://xmlns.com/foaf/0.1/avatar&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>  <span class="diff">"@context": {<ins class="diff-chg">
    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": "http://xmlns.com/foaf/0.1/homepage",
    "avatar": "http://xmlns.com/foaf/0.1/avatar"
</ins>
  },</span>
<del class="diff-old">  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;,
  &quot;avatar&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;
</del>
<ins class="diff-chg">  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/",
  "avatar": "http://twitter.com/account/profile_image/manusporny"
</ins>
}
</pre>
<p>
JSON-LD
strives
to
ensure
that
developers
don't
have
to
change
the
JSON
that
is
going
into
and
being
returned
from
their
Web
APIs.
This
means
that
developers
can
also
specify
a
context
for
JSON
data
in
an
out-of-band
fashion.
This
is
described
later
in
this
document.
</p>
<p>
JSON-LD
uses
a
special
type
of
machine-readable
document
called
a
<dfn title="Web_Vocabulary" id="dfn-web_vocabulary">
Web
Vocabulary
</dfn>
to
define
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
that
are
then
used
to
describe
concepts
and
<del class="diff-old">&quot;things&quot;
</del>
<ins class="diff-chg">"things"
</ins>
in
the
world.
Typically,
these
Web
Vocabulary
documents
have
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>
es
associated
with
them
and
contain
a
number
of
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
declarations.
A
<dfn title="prefix" id="dfn-prefix">
prefix
</dfn>,
like
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>,
is
a
short
word
that
expands
to
a
Web
Vocabulary
base
IRI.
<a class="tref internalDFN" title="Prefix" href="#dfn-prefix-1">
Prefix
</a>
es
are
helpful
when
a
developer
wants
to
mix
multiple
vocabularies
together
in
a
context,
but
does
not
want
to
go
to
the
trouble
of
defining
every
single
term
in
every
single
vocabulary.
Some
Web
Vocabularies
may
have
dozens
of
terms
defined.
If
a
developer
wants
to
use
3-4
different
vocabularies,
the
number
of
terms
that
would
have
to
be
declared
in
a
single
context
could
become
quite
large.
To
reduce
the
number
of
different
terms
that
must
be
defined,
JSON-LD
also
allows
prefixes
to
be
used
to
compact
IRIs.
</p>
<p>
</p>
<p>
For
example,
the
IRI
<code>
http://xmlns.com/foaf/0.1/
</code>
specifies
a
<a class="tref internalDFN" title="Web_Vocabulary" href="#dfn-web_vocabulary">
Web
Vocabulary
</a>
which
may
be
represented
using
the
<code>
foaf
</code>
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>.
The
<code>
foaf
</code>
Web
Vocabulary
contains
a
term
called
<strong>
name
</strong>.
If
you
join
the
<code>
foaf
</code>
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>
with
the
<strong>
name
</strong>
suffix,
you
can
build
a
compact
IRI
that
will
expand
out
into
an
absolute
IRI
for
the
<code>
http://xmlns.com/foaf/0.1/name
</code>
vocabulary
term.
That
is,
the
compact
IRI,
or
short-form,
is
<code>
foaf:name
</code>
and
the
expanded-form
is
<code>
http://xmlns.com/foaf/0.1/name
</code>.
This
vocabulary
term
is
used
to
specify
a
person's
name.
</p>
<p>
Developers,
and
machines,
are
able
to
use
this
IRI
(plugging
it
directly
into
a
web
browser,
for
instance)
to
go
to
the
term
and
get
a
definition
of
what
the
term
means.
Much
like
we
can
use
<a href="http://wordnet.princeton.edu/">
WordNet
</a>
today
to
see
the
definition
of
words
in
the
English
language.
Developers
and
machines
need
the
same
sort
of
definition
of
terms.
IRIs
provide
a
way
to
ensure
that
these
terms
are
unambiguous.
</p>
<p>
The
context
provides
a
collection
of
vocabulary
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
and
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>
es
that
can
be
used
to
expand
JSON
keys
and
values
into
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
s.
</p>
<del class="diff-old">To
ensure
the
best
possible
performance,
it
is
a
best
practice
to
put
the
context
definition
at
the
top
of
the
JSON-LD
document.
If
it
isn't
listed
first,
processors
have
to
save
each
key-value
pair
until
the
context
is
processed.
This
creates
a
memory
and
complexity
burden
for
one-pass
processors.
</del>
</div>
<div id="from-json-to-json-ld" class="section">
<h3>
<span class="secno">
2.5
</span>
From
JSON
to
JSON-LD
</h3>
<p>
If
a
set
of
terms
such
as,
<strong>
name
</strong>,
<strong>
homepage
</strong>,
and
<strong>
avatar
</strong>,
are
defined
in
a
context,
and
that
context
is
used
to
resolve
the
names
in
JSON
objects,
machines
are
able
to
automatically
expand
the
terms
to
something
meaningful
and
unambiguous,
like
this:
</p>
<del class="diff-old">{
  &quot;&quot;: &quot;Manu Sporny&quot;,
  &quot;&quot;: &quot;http://manu.sporny.org&quot;
  &quot;&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
  "<span class="diff">http://xmlns.com/foaf/0.1/name</span>": "Manu Sporny",
  "<span class="diff">http://xmlns.com/foaf/0.1/homepage</span>": "http://manu.sporny.org"
  "<span class="diff">http://rdfs.org/sioc/ns#avatar</span>": "http://twitter.com/account/profile_image/manusporny"
</ins>
}
</pre>
<p>
Doing
this
allows
JSON
to
be
unambiguously
machine-readable
without
requiring
developers
to
drastically
change
their
workflow.
</p>
<p class="note">
Please
note
that
this
JSON-LD
document
doesn't
define
the
subject
and
will
thus
result
in
an
unlabeled
or
blank
node.
</p>
</div>
</div>
<div id="basic-concepts" class="section">
<h2>
<span class="secno">
3.
</span>
Basic
Concepts
</h2>
<p>
JSON-LD
is
designed
to
ensure
that
Linked
Data
concepts
can
be
marked
up
in
a
way
that
is
simple
to
understand
and
author
by
Web
developers.
In
many
cases,
regular
JSON
markup
can
become
Linked
Data
with
the
simple
addition
of
a
context.
As
more
JSON-LD
features
are
used,
more
semantics
are
added
to
the
JSON
markup.
</p>
<div id="iris" class="section">
<h3>
<span class="secno">
3.1
</span>
IRIs
</h3>
<p>
Expressing
IRIs
are
fundamental
to
Linked
Data
as
that
is
how
most
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>
s
and
many
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
are
named.
IRIs
can
be
expressed
in
a
variety
of
different
ways
in
JSON-LD.
</p>
<ol>
<li>
In
general,
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
in
the
key
position
in
a
<a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">
JSON
object
</a>
that
have
a
mapping
to
an
IRI
or
another
key
in
the
context
are
expanded
to
an
IRI
by
JSON-LD
processors.
There
are
special
rules
for
processing
keys
in
<code>
@context
</code>
and
when
dealing
with
keys
that
start
with
the
<code>
@subject
</code>
character.
</li>
<li>
An
IRI
is
generated
for
the
value
specified
using
<code>
@subject
</code>,
if
it
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>.
</li>
<li>
An
IRI
is
generated
for
the
value
specified
using
<code>
@type
</code>.
</li>
<li>
An
IRI
is
generated
for
the
value
specified
using
the
<code>
@iri
</code>
keyword.
</li>
<li>
An
IRI
is
generated
when
there
are
<code>
@coerce
</code>
rules
in
effect
for
a
key
named
<code>
@iri
</code>.
</li>
</ol>
<p>
IRIs
can
be
expressed
directly
in
the
key
position
like
so:
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;&quot;: &quot;Manu Sporny&quot;,
</del>
<ins class="diff-chg">  "<span class="diff">http://xmlns.com/foaf/0.1/name</span>": "Manu Sporny",
</ins>
...
}
</pre>
<p>
In
the
example
above,
the
key
<code>
http://xmlns.com/foaf/0.1/name
</code>
is
interpreted
as
an
IRI,
as
opposed
to
being
interpreted
as
a
string.
</p>
<p>
Term
expansion
occurs
for
IRIs
if
a
term
is
defined
within
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>:
</p>
<del class="diff-old">{
  &quot;&quot;},
</del>
<pre class="example">
<ins class="diff-chg">{
  "<span class="diff">@context</span>": {"<span class="diff">name</span>": "<span class="diff">http://xmlns.com/foaf/0.1/name</span>"},
</ins>
...
<del class="diff-old">  &quot;&quot;: &quot;Manu Sporny&quot;,
</del>
<ins class="diff-chg">  "<span class="diff">name</span>": "Manu Sporny",
</ins>
...
}
</pre>
<p>
<a class="tref internalDFN" title="Prefix" href="#dfn-prefix-1">
Prefix
</a>
es
are
expanded
when
used
in
keys:
</p>
<del class="diff-old">{
  &quot;&quot;},
</del>
<pre class="example">
<ins class="diff-chg">{
  "<span class="diff">@context</span>": {"<span class="diff">foaf</span>": "<span class="diff">http://xmlns.com/foaf/0.1/</span>"},
</ins>
...
<del class="diff-old">  &quot;&quot;: &quot;Manu Sporny&quot;,
</del>
<ins class="diff-chg">  "<span class="diff">foaf:name</span>": "Manu Sporny",
</ins>
...
}
</pre>
<p>
<code>
foaf:name
</code>
above
will
automatically
expand
out
to
the
IRI
<code>
http://xmlns.com/foaf/0.1/name
</code>.
</p>
<p>
An
IRI
is
generated
when
a
value
is
associated
with
a
key
using
the
<code>
@iri
</code>
keyword:
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;homepage&quot;: { &quot;&quot;: &quot;http://manu.sporny.org&quot; }
</del>
<ins class="diff-chg">  "homepage": { "<span class="diff">@iri</span>": "http://manu.sporny.org" }
</ins>
...
}
</pre>
<p>
If
type
coercion
rules
are
specified
in
the
<code>
@context
</code>
for
a
particular
vocabulary
term,
an
IRI
is
generated:
</p>
<del class="diff-old">  &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{<span class="diff">
  "@context":
</ins>
  {
    ...
<del class="diff-old">    &quot;@coerce&quot;:
</del>
<ins class="diff-chg">    "@coerce":
</ins>
    {
<del class="diff-old">      &quot;@iri&quot;: &quot;homepage&quot;
</del>
<ins class="diff-chg">      "@iri": "homepage"
</ins>
    }
  }</span>
...
<del class="diff-old">  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;,
</del>
<ins class="diff-chg">  "homepage": "http://manu.sporny.org/",
</ins>
...
}
</pre>
<p>
Even
though
the
value
<code>
http://manu.sporny.org/
</code>
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
the
type
coercion
rules
will
transform
the
value
into
an
IRI
when
processed
by
a
JSON-LD
Processor
</p>
</div>
<div id="identifying-the-subject" class="section">
<h3>
<span class="secno">
3.2
</span>
Identifying
the
Subject
</h3>
<p>
To
be
able
to
externally
reference
nodes,
it
is
important
that
each
node
has
an
unambiguous
identifier.
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
s
are
a
fundamental
concept
of
Linked
Data,
and
nodes
should
have
a
de-referencable
identifier
used
to
name
and
locate
them.
For
nodes
to
be
truely
linked,
de-referencing
the
identifier
should
result
in
a
representation
of
that
node.
Associating
an
IRI
with
a
node
tells
an
application
that
the
returned
document
contains
a
description
of
the
node
requested.
</p>
<p>
JSON-LD
documents
may
also
contain
descriptions
of
other
nodes,
so
it
is
necessary
to
be
able
to
uniquely
identify
each
node
which
may
be
externally
referenced.
</p>
<p>
A
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>
of
an
object
in
JSON
is
declared
using
the
<code>
@subject
</code>
key.
The
subject
is
the
first
piece
of
information
needed
by
the
JSON-LD
processor
in
order
to
create
the
(subject,
property,
object)
tuple,
also
known
as
a
triple.
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;&quot;,
</del>
<ins class="diff-chg">  "<span class="diff">@subject</span>": "<span class="diff">http://example.org/people#joebob</span>",
</ins>
...
}
</pre>
<p>
The
example
above
would
set
the
subject
to
the
IRI
<code>
http://example.org/people#joebob
</code>.
</p>
<del class="diff-old">To
ensure
the
best
possible
performance,
it
is
a
best
practice
to
put
the
@subject
key
before
other
key-value
pairs
in
an
object.
If
it
isn't
listed
first,
processors
have
to
save
each
key-value
pair
until
@subject
is
processed
before
they
can
create
valid
triples.
This
creates
a
memory
and
complexity
burden
for
one-pass
processors.
</del>
</div>
<div id="specifying-the-type" class="section">
<h3>
<span class="secno">
3.3
</span>
Specifying
the
Type
</h3>
<p>
The
type
of
a
particular
subject
can
be
specified
using
the
<code>
@type
</code>
key.
Specifying
the
type
in
this
way
will
generate
a
triple
of
the
form
(subject,
type,
type-iri).
</p>
<p>
To
be
Linked
Data,
types
<em class="rfc2119" title="must">
must
</em>
be
uniquely
identified
by
an
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>.
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;@subject&quot;: &quot;http://example.org/people#joebob&quot;,
  &quot;&quot;,
</del>
<ins class="diff-chg">  "@subject": "http://example.org/people#joebob",
  "<span class="diff">@type</span>": "<span class="diff">http://xmlns.com/foaf/0.1/Person</span>",
</ins>
...
}
</pre>
<p>
The
example
above
would
generate
the
following
triple
if
the
JSON-LD
document
is
mapped
to
RDF
(in
N-Triples
notation):
</p>
<del class="diff-old">&lt;http://example.org/people#joebob&gt;
</del>
<pre class="example">
<ins class="diff-chg">&lt;http://example.org/people#joebob&gt;
</ins>
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
&lt;http://xmlns.com/foaf/0.1/Person&gt;
.
</pre>
</div>
<div id="strings" class="section">
<h3>
<span class="secno">
3.4
</span>
Strings
</h3>
<p>
Regular
text
strings,
also
referred
to
as
<dfn title="plain_literal" id="dfn-plain_literal">
plain
literal
</dfn>
s,
are
easily
expressed
using
regular
JSON
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>
s.
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;name&quot;: &quot;&quot;,
</del>
<ins class="diff-chg">  "name": "<span class="diff">Mark Birbeck</span>",
</ins>
...
}
</pre>
</div>
<div id="string-internationalization" class="section">
<h3>
<span class="secno">
3.5
</span>
String
Internationalization
</h3>
<p>
JSON-LD
makes
an
assumption
that
strings
with
associated
language
encoding
information
are
not
very
common
when
used
in
JavaScript
and
Web
Services.
Thus,
it
takes
a
little
more
effort
to
express
strings
with
associated
language
information.
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;name&quot;: 
</del>
<ins class="diff-chg">  "name": <span class="diff">
</ins>
  {
<del class="diff-old">    &quot;@literal&quot;: &quot;花澄&quot;,
    &quot;@language&quot;: &quot;ja&quot;
</del>
<ins class="diff-chg">    "@literal": "花澄",
    "@language": "ja"
</ins>
  }</span>
...
}
</pre>
<p>
The
example
above
would
generate
a
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>
for
<em>
花澄
</em>
and
associate
the
<code>
ja
</code>
language
code
with
the
triple
that
is
generated.
Languages
<em class="rfc2119" title="must">
must
</em>
be
expressed
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-BCP47">
BCP47
</a>
</cite>
]
format.
</p>
</div>
<div id="datatypes" class="section">
<h3>
<span class="secno">
3.6
</span>
Datatypes
</h3>
<p>
A
value
with
an
associated
datatype,
also
known
as
a
<dfn title="typed_literal" id="dfn-typed_literal">
typed
literal
</dfn>,
is
indicated
by
associating
a
literal
with
an
IRI
which
indicates
the
literal's
datatype.
Typed
literals
may
be
expressed
in
JSON-LD
in
three
ways:
</p>
<ol>
<li>
By
utilizing
the
<code>
@coerce
</code>
keyword.
</li>
<li>
By
utilizing
the
expanded
form
for
specifying
objects.
</li>
<li>
By
using
a
native
JSON
datatype.
</li>
</ol>
<p>
The
first
example
uses
the
<code>
@coerce
</code>
keyword
to
express
a
typed
literal:
</p>
<del class="diff-old">  &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{<span class="diff">
  "@context":
</ins>
  {
<del class="diff-old">    &quot;modified&quot;:  &quot;http://purl.org/dc/terms/modified&quot;,
    &quot;dateTime&quot;: &quot;http://www.w3.org/2001/XMLSchema#dateTime&quot;
    &quot;@coerce&quot;:
</del>
<ins class="diff-chg">    "modified":  "http://purl.org/dc/terms/modified",
    "dateTime": "http://www.w3.org/2001/XMLSchema#dateTime"
    "@coerce":
</ins>
    {
<del class="diff-old">      &quot;dateTime&quot;: &quot;modified&quot;
</del>
<ins class="diff-chg">      "dateTime": "modified"
</ins>
    }
  }</span>
...
<del class="diff-old">  &quot;modified&quot;: &quot;2010-05-29T14:17:39+02:00&quot;,
</del>
<ins class="diff-chg">  "modified": "2010-05-29T14:17:39+02:00",
</ins>
...
}
</pre>
<p>
The
second
example
uses
the
expanded
form
for
specifying
objects:
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;modified&quot;: 
</del>
<ins class="diff-chg">  "modified": <span class="diff">
</ins>
  {
<del class="diff-old">    &quot;@literal&quot;: &quot;2010-05-29T14:17:39+02:00&quot;,
    &quot;@datatype&quot;: &quot;dateTime&quot;
</del>
<ins class="diff-chg">    "@literal": "2010-05-29T14:17:39+02:00",
    "@datatype": "dateTime"
</ins>
  }</span>
...
}
</pre>
<p>
Both
examples
above
would
generate
an
object
with
the
literal
value
of
<code>
2010-05-29T14:17:39+02:00
</code>
and
the
datatype
of
<code>
http://www.w3.org/2001/XMLSchema#dateTime
</code>.
</p>
<p>
The
third
example
uses
a
built-in
native
JSON
type,
a
<a class="tref internalDFN" title="number" href="#dfn-number">
number
</a>,
to
express
a
datatype:
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;@subject&quot;: &quot;http://example.org/people#joebob&quot;,
  &quot;age&quot;: 
</del>
<ins class="diff-chg">  "@subject": "http://example.org/people#joebob",
  "age": <span class="diff">31</span>
</ins>
...
}
</pre>
<p>
The
example
above
would
generate
the
following
triple:
</p>
<del class="diff-old">&lt;http://example.org/people#joebob&gt;
</del>
<pre class="example">
<ins class="diff-chg">&lt;http://example.org/people#joebob&gt;
</ins>
   &lt;http://xmlns.com/foaf/0.1/age&gt;
<del class="diff-old">&quot;31&quot;^^&lt;http://www.w3.org/2001/XMLSchema#integer&gt;
</del>
<ins class="diff-chg">"31"^^&lt;http://www.w3.org/2001/XMLSchema#integer&gt;
</ins>
.
</pre>
</div>
<div id="multiple-objects-for-a-single-property" class="section">
<h3>
<span class="secno">
3.7
</span>
Multiple
Objects
for
a
Single
Property
</h3>
<p>
A
JSON-LD
author
can
express
multiple
triples
in
a
compact
way
by
using
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
s.
If
a
subject
has
multiple
values
for
the
same
property,
the
author
<em class="rfc2119" title="may">
may
</em>
express
each
property
as
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
</p>
<p class="note">
In
JSON-LD,
multiple
objects
on
a
property
are
not
ordered.
This
is
because
typically
graphs
are
not
inherently
ordered
data
structures.
To
see
more
on
creating
ordered
collections
in
JSON-LD,
see
<a href="#lists">
Lists
</a>.
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;@subject&quot;: &quot;http://example.org/people#joebob&quot;,
  &quot;nick&quot;: ,
</del>
<ins class="diff-chg">  "@subject": "http://example.org/people#joebob",
  "nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
</ins>
...
}
</pre>
<p>
The
markup
shown
above
would
generate
the
following
triples:
</p>
<del class="diff-old">&lt;http://example.org/people#joebob&gt;
</del>
<pre class="example">
<ins class="diff-chg">&lt;http://example.org/people#joebob&gt;
</ins>
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
<del class="diff-old">      &quot;joe&quot; .
</del>
<ins class="diff-chg">      "joe" .
</ins>
&lt;http://example.org/people#joebob&gt;
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
<del class="diff-old">      &quot;bob&quot; .
</del>
<ins class="diff-chg">      "bob" .
</ins>
&lt;http://example.org/people#joebob&gt;
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
<del class="diff-old">&quot;jaybee&quot;
</del>
<ins class="diff-chg">"jaybee"
</ins>
.
</pre>
</div>
<div id="multiple-typed-literals-for-a-single-property" class="section">
<h3>
<span class="secno">
3.8
</span>
Multiple
Typed
Literals
for
a
Single
Property
</h3>
<p>
Multiple
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
s
may
also
be
expressed
using
the
expanded
form
for
objects:
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;@subject&quot;: &quot;http://example.org/articles/8&quot;,
  &quot;modified&quot;: 
</del>
<ins class="diff-chg">  "@subject": "http://example.org/articles/8",
  "modified": <span class="diff">
</ins>
  [
    {
<del class="diff-old">      &quot;@literal&quot;: &quot;2010-05-29T14:17:39+02:00&quot;,
      &quot;@datatype&quot;: &quot;dateTime&quot;
</del>
<ins class="diff-chg">      "@literal": "2010-05-29T14:17:39+02:00",
      "@datatype": "dateTime"
</ins>
    },
    {
<del class="diff-old">      &quot;@literal&quot;: &quot;2010-05-30T09:21:28-04:00&quot;,
      &quot;@datatype&quot;: &quot;dateTime&quot;
</del>
<ins class="diff-chg">      "@literal": "2010-05-30T09:21:28-04:00",
      "@datatype": "dateTime"
</ins>
    }
  ]</span>
...
}
</pre>
<p>
The
markup
shown
above
would
generate
the
following
triples:
</p>
<del class="diff-old">&lt;http://example.org/articles/8&gt;
</del>
<pre class="example">
<ins class="diff-chg">&lt;http://example.org/articles/8&gt;
</ins>
   &lt;http://purl.org/dc/terms/modified&gt;
<del class="diff-old">      &quot;2010-05-29T14:17:39+02:00&quot;^^http://www.w3.org/2001/XMLSchema#dateTime .
</del>
<ins class="diff-chg">      "2010-05-29T14:17:39+02:00"^^http://www.w3.org/2001/XMLSchema#dateTime .
</ins>
&lt;http://example.org/articles/8&gt;
   &lt;http://purl.org/dc/terms/modified&gt;
<del class="diff-old">&quot;2010-05-30T09:21:28-04:00&quot;^^http://www.w3.org/2001/XMLSchema#dateTime
</del>
<ins class="diff-chg">"2010-05-30T09:21:28-04:00"^^http://www.w3.org/2001/XMLSchema#dateTime
</ins>
.
</pre>
</div>
<div id="expansion" class="section">
<h3>
<span class="secno">
3.9
</span>
Expansion
</h3>
<p>
Expansion
is
the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
all
IRI,
datatypes,
and
literal
values
are
expanded
so
that
the
context
is
no
longer
necessary.
JSON-LD
document
expansion
is
typically
used
as
a
part
of
<a href="#normalization">
Framing
</a>
or
<a href="#normalization">
Normalization
</a>.
</p>
<p>
For
example,
assume
the
following
JSON-LD
input
document:
</p>
<del class="diff-old">{
   &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
   "@context":
</ins>
   {
<del class="diff-old">      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@coerce&quot;:
</del>
<ins class="diff-chg">      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "@coerce":
</ins>
      {
<del class="diff-old">         &quot;@iri&quot;: &quot;homepage&quot;
</del>
<ins class="diff-chg">         "@iri": "homepage"
</ins>
      }
   },
<del class="diff-old">   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<ins class="diff-chg">   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/"
</ins>
}
</pre>
<p>
Running
the
JSON-LD
Expansion
algorithm
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
</p>
<del class="diff-old">{
   &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
   &quot;http://xmlns.com/foaf/0.1/homepage&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
   "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
   "http://xmlns.com/foaf/0.1/homepage":
</ins>
   {
<del class="diff-old">      &quot;@iri&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<ins class="diff-chg">      "@iri": "http://manu.sporny.org/"
</ins>
   }
}
</pre>
</div>
<div id="compaction" class="section">
<h3>
<span class="secno">
3.10
</span>
Compaction
</h3>
<p>
Compaction
is
the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
the
most
compact
form
of
the
document
is
generated.
JSON
is
typically
expressed
in
a
very
compact,
key-value
format.
That
is,
full
IRIs
are
rarely
used
as
keys.
At
times,
a
JSON-LD
document
may
be
received
that
is
not
in
its
most
compact
form.
JSON-LD,
via
the
API,
provides
a
way
to
compact
a
JSON-LD
document.
</p>
<p>
For
example,
assume
the
following
JSON-LD
input
document:
</p>
<del class="diff-old">{
   &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
   &quot;http://xmlns.com/foaf/0.1/homepage&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
   "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
   "http://xmlns.com/foaf/0.1/homepage":
</ins>
   {
<del class="diff-old">      &quot;@iri&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<ins class="diff-chg">      "@iri": "http://manu.sporny.org/"
</ins>
   }
}
</pre>
<p>
Additionally,
assume
the
following
developer-supplied
JSON-LD
context:
</p>
<del class="diff-old">{
   &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
   &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
   &quot;@coerce&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
   "name": "http://xmlns.com/foaf/0.1/name",
   "homepage": "http://xmlns.com/foaf/0.1/homepage",
   "@coerce":
</ins>
   {
<del class="diff-old">      &quot;@iri&quot;: &quot;homepage&quot;
</del>
<ins class="diff-chg">      "@iri": "homepage"
</ins>
   }
}
</pre>
<p>
Running
the
JSON-LD
Compaction
algorithm
given
the
context
supplied
above
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
</p>
<del class="diff-old">{
   &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
   "@context":
</ins>
   {
<del class="diff-old">      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@coerce&quot;:
</del>
<ins class="diff-chg">      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "@coerce":
</ins>
      {
<del class="diff-old">         &quot;@iri&quot;: &quot;homepage&quot;
</del>
<ins class="diff-chg">         "@iri": "homepage"
</ins>
      }
   },
<del class="diff-old">   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<ins class="diff-chg">   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/"
</ins>
}
</pre>
<p>
The
compaction
algorithm
also
enables
the
developer
to
map
any
expanded
format
into
an
application-specific
compacted
format.
While
the
context
provided
above
mapped
<code>
http://xmlns.com/foaf/0.1/name
</code>
to
<strong>
name
</strong>,
it
could
have
also
mapped
it
to
any
arbitrary
string
provided
by
the
developer.
</p>
</div>
<div id="framing" class="section">
<h3>
<span class="secno">
3.11
</span>
Framing
</h3>
<p>
A
JSON-LD
document
is
a
representation
of
a
directed
graph.
A
single
directed
graph
can
have
many
different
serializations,
each
expressing
exactly
the
same
information.
Developers
typically
work
with
trees,
represented
as
<a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">
JSON
object
</a>
s.
While
mapping
a
graph
to
a
tree
can
be
done,
the
layout
of
the
end
result
must
be
specified
in
advance.
A
<dfn title="Frame" id="dfn-frame">
Frame
</dfn>
can
be
used
by
a
developer
on
a
JSON-LD
document
to
specify
a
deterministic
layout
for
a
graph.
</p>
<p>
Framing
is
the
process
of
taking
a
JSON-LD
document,
which
expresses
a
graph
of
information,
and
applying
a
specific
graph
layout
(called
a
<a class="tref internalDFN" title="Frame" href="#dfn-frame">
Frame
</a>
).
</p>
<p>
The
JSON-LD
document
below
expresses
a
library,
a
book
and
a
chapter:
</p>
<del class="diff-old">{
  &quot;@context&quot;: {
    &quot;Book&quot;:         &quot;http://example.org/vocab#Book&quot;,
    &quot;Chapter&quot;:      &quot;http://example.org/vocab#Chapter&quot;,
    &quot;contains&quot;:     &quot;http://example.org/vocab#contains&quot;,
    &quot;creator&quot;:      &quot;http://purl.org/dc/terms/creator&quot;
    &quot;description&quot;:  &quot;http://purl.org/dc/terms/description&quot;
    &quot;Library&quot;:      &quot;http://example.org/vocab#Library&quot;,
    &quot;title&quot;:        &quot;http://purl.org/dc/terms/title&quot;,
    &quot;@coerce&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title",
    "@coerce":
</ins>
    {
<del class="diff-old">      &quot;@iri&quot;: &quot;contains&quot;
</del>
<ins class="diff-chg">      "@iri": "contains"
</ins>
    },
  },
<del class="diff-old">  &quot;@subject&quot;:
</del>
<ins class="diff-chg">  "@subject":
</ins>
  [{
<del class="diff-old">    &quot;@subject&quot;: &quot;http://example.com/library&quot;,
    &quot;@type&quot;: &quot;Library&quot;,
    &quot;contains&quot;: &quot;http://example.org/library/the-republic&quot;
</del>
<ins class="diff-chg">    "@subject": "http://example.com/library",
    "@type": "Library",
    "contains": "http://example.org/library/the-republic"
</ins>
  },
  {
<del class="diff-old">    &quot;@subject&quot;: &quot;http://example.org/library/the-republic&quot;,
    &quot;@type&quot;: &quot;Book&quot;,
    &quot;creator&quot;: &quot;Plato&quot;,
    &quot;title&quot;: &quot;The Republic&quot;,
    &quot;contains&quot;: &quot;http://example.org/library/the-republic#introduction&quot;
</del>
<ins class="diff-chg">    "@subject": "http://example.org/library/the-republic",
    "@type": "Book",
    "creator": "Plato",
    "title": "The Republic",
    "contains": "http://example.org/library/the-republic#introduction"
</ins>
  },
  {
<del class="diff-old">    &quot;@subject&quot;: &quot;http://example.org/library/the-republic#introduction&quot;,
    &quot;@type&quot;: &quot;Chapter&quot;,
    &quot;description&quot;: &quot;An introductory chapter on The Republic.&quot;,
    &quot;title&quot;: &quot;The Introduction&quot;
</del>
<ins class="diff-chg">    "@subject": "http://example.org/library/the-republic#introduction",
    "@type": "Chapter",
    "description": "An introductory chapter on The Republic.",
    "title": "The Introduction"
</ins>
  }]
}
</pre>
<p>
Developers
typically
like
to
operate
on
items
in
a
hierarchical,
tree-based
fashion.
Ideally,
a
developer
would
want
the
data
above
sorted
into
top-level
libraries,
then
the
books
that
are
contained
in
each
library,
and
then
the
chapters
contained
in
each
book.
To
achieve
that
layout,
the
developer
can
define
the
following
<a class="tref internalDFN" title="frame" href="#dfn-frame">
frame
</a>:
</p>
<del class="diff-old">{
  &quot;@context&quot;: {
    &quot;Book&quot;:         &quot;http://example.org/vocab#Book&quot;,
    &quot;Chapter&quot;:      &quot;http://example.org/vocab#Chapter&quot;,
    &quot;contains&quot;:     &quot;http://example.org/vocab#contains&quot;,
    &quot;creator&quot;:      &quot;http://purl.org/dc/terms/creator&quot;
    &quot;description&quot;:  &quot;http://purl.org/dc/terms/description&quot;
    &quot;Library&quot;:      &quot;http://example.org/vocab#Library&quot;,
    &quot;title&quot;:        &quot;http://purl.org/dc/terms/title&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title"
</ins>
  },
<del class="diff-old">  &quot;@type&quot;: &quot;Library&quot;,
  &quot;contains&quot;: {
    &quot;@type&quot;: &quot;Book&quot;,
    &quot;contains&quot;: {
      &quot;@type&quot;: &quot;Chapter&quot;
</del>
<ins class="diff-chg">  "@type": "Library",
  "contains": {
    "@type": "Book",
    "contains": {
      "@type": "Chapter"
</ins>
    }
  }
}
</pre>
<p>
When
the
framing
algorithm
is
run
against
the
previously
defined
JSON-LD
document,
paired
with
the
<a class="tref internalDFN" title="frame" href="#dfn-frame">
frame
</a>
above,
the
following
JSON-LD
document
is
the
end
result:
</p>
<del class="diff-old">{
  &quot;@context&quot;: {
    &quot;Book&quot;:         &quot;http://example.org/vocab#Book&quot;,
    &quot;Chapter&quot;:      &quot;http://example.org/vocab#Chapter&quot;,
    &quot;contains&quot;:     &quot;http://example.org/vocab#contains&quot;,
    &quot;creator&quot;:      &quot;http://purl.org/dc/terms/creator&quot;
    &quot;description&quot;:  &quot;http://purl.org/dc/terms/description&quot;
    &quot;Library&quot;:      &quot;http://example.org/vocab#Library&quot;,
    &quot;title&quot;:        &quot;http://purl.org/dc/terms/title&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title"
</ins>
  },
<del class="diff-old">  &quot;@subject&quot;: &quot;http://example.org/library&quot;,
  &quot;@type&quot;: &quot;Library&quot;,
  &quot;contains&quot;: {
    
    &quot;@type&quot;: &quot;Book&quot;,
    
    
    &quot;contains&quot;: {
      
      &quot;@type&quot;: &quot;Chapter&quot;,
      
      
</del>
<ins class="diff-chg">  "@subject": "http://example.org/library",
  "@type": "Library",
  "contains": {
</ins>    <span class="diff">"@subject": "http://example.org/library/the-republic",</span><ins class="diff-chg">
    "@type": "Book",
</ins>    <span class="diff">"creator": "Plato",</span>    <span class="diff">"title": "The Republic",</span><ins class="diff-chg">
    "contains": {
</ins>      <span class="diff">"@subject": "http://example.org/library/the-republic#introduction",</span><ins class="diff-chg">
      "@type": "Chapter",
</ins>      <span class="diff">"description": "An introductory chapter on The Republic.",</span>      <span class="diff">"title": "The Introduction"</span>
    },
  },
}
</pre>
<p>
The
JSON-LD
framing
algorithm
allows
developers
to
query
by
example
and
force
a
specific
tree
layout
to
a
JSON-LD
document.
</p>
</div>
</div>
<div id="advanced-concepts" class="section">
<h2>
<span class="secno">
4.
</span>
Advanced
Concepts
</h2>
<p>
JSON-LD
has
a
number
of
features
that
provide
functionality
above
and
beyond
the
core
functionality
described
above.
The
following
sections
outline
the
features
that
are
specific
to
JSON-LD.
</p>
<del class="diff-old">4.1
External
Contexts
Authors
may
choose
to
declare
JSON-LD
context
s
in
external
documents
to
promote
re-use
of
contexts
as
well
as
reduce
the
size
of
JSON-LD
documents.
In
order
to
use
an
external
context,
an
author
may
specify
an
IRI
to
a
valid
JSON-LD
document.
If
an
IRI
is
specified,
the
external
document
must
be
dereferenced
and
the
top-level
@context
key
in
the
JSON
Object
must
be
overlayed
on
top
of
the
current
active
context.
The
following
example
demonstrates
the
use
of
an
external
context:
{
  ,
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;,
  &quot;avatar&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;
}
Authors
may
also
import
multiple
contexts
by
specifying
a
list
of
contexts
to
import:
{
  
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;,
  &quot;avatar&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;
  &quot;celebrates&quot;:
  {
     &quot;@type&quot;: &quot;Event&quot;,
     &quot;description&quot;: &quot;International Talk Like a Pirate Day&quot;,
     &quot;date&quot;: &quot;R/2011-09-19&quot;
  }
}
Each
context
in
a
list
will
be
evaluated
in-order.
Duplicate
values
must
be
overwritten
on
a
last-defined-overrides
basis.
The
context
list
must
contain
either
de-referenceable
IRIs
or
JSON
Object
s
that
conform
to
the
context
syntax
as
described
in
this
document.
External
JSON-LD
context
documents
may
contain
extra
information
located
outside
of
the
@context
key,
such
as
documentation
about
the
prefix
es
declared
in
the
document.
It
is
also
recommended
that
a
human-readable
document
encoded
in
HTML+RDFa
[
HTML-RDFA
]
or
other
Linked
Data
compatible
format
is
served
as
well
to
explain
the
correct
usage
of
the
JSON-LD
context
document.
</del>
<div id="vocabulary-prefixes" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.2
</del>
<ins class="diff-chg">4.1
</ins>
</span>
Vocabulary
Prefixes
</h3>
<p>
Vocabulary
terms
in
Linked
Data
documents
may
draw
from
a
number
of
different
Web
vocabularies.
At
times,
declaring
every
single
term
that
a
document
uses
can
require
the
developer
to
declare
tens,
if
not
hundreds
of
potential
vocabulary
terms
that
may
be
used
across
an
application.
This
is
a
concern
for
at
least
three
reasons;
the
first
is
the
cognitive
load
on
the
developer,
the
second
is
the
serialized
size
of
the
context,
the
third
is
future-proofing
application
contexts.
In
order
to
address
these
issues,
the
concept
of
a
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>
mechanism
is
introduced.
</p>
<p>
A
<dfn title="prefix" id="dfn-prefix-1">
prefix
</dfn>
is
a
compact
way
of
expressing
a
base
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
to
a
<a class="tref internalDFN" title="Web_Vocabulary" href="#dfn-web_vocabulary">
Web
Vocabulary
</a>.
Generally,
these
prefixes
are
used
by
concatenating
the
<em>
prefix
</em>
and
a
<em>
term
</em>
separated
by
a
colon
(
<code>:
</code>
).
The
prefix
is
a
short
string
that
identifies
a
particular
Web
vocabulary.
For
example,
the
prefix
<code>
foaf
</code>
may
be
used
as
a
short
hand
for
the
Friend-of-a-Friend
Web
Vocabulary,
which
is
identified
using
the
IRI
<code>
http://xmlns.com/foaf/0.1/
</code>.
A
developer
may
append
any
of
the
FOAF
Vocabulary
terms
to
the
end
of
the
prefix
to
specify
a
short-hand
version
of
the
full
IRI
for
the
vocabulary
term.
For
example,
<code>
foaf:name
</code>
would
be
expanded
out
to
the
IRI
<code>
http://xmlns.com/foaf/0.1/name
</code>.
Instead
of
having
to
remember
and
type
out
the
entire
IRI,
the
developer
can
instead
use
the
prefix
in
their
JSON-LD
markup.
</p>
<p>
The
ability
to
use
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>
es
reduces
the
need
for
developers
to
declare
every
vocabulary
term
that
they
intend
to
use
in
the
JSON-LD
context.
This
reduces
document
serialization
size
because
every
vocabulary
term
need
not
be
declared
in
the
context.
<a class="tref internalDFN" title="Prefix" href="#dfn-prefix-1">
Prefix
</a>
also
reduce
the
cognitive
load
on
the
developer.
It
is
far
easier
to
remember
<code>
foaf:name
</code>
than
it
is
to
remember
<code>
http://xmlns.com/foaf/0.1/name
</code>.
The
use
of
prefixes
also
ensures
that
a
context
document
does
not
have
to
be
updated
in
lock-step
with
an
externally
defined
<a class="tref internalDFN" title="Web_Vocabulary" href="#dfn-web_vocabulary">
Web
Vocabulary
</a>.
Without
prefixes,
a
developer
would
need
to
keep
their
application
context
terms
in
lock-step
with
an
externally
defined
Web
Vocabulary.
Rather,
by
just
declaring
the
Web
Vocabulary
prefix,
one
can
use
new
terms
as
they're
declared
without
having
to
update
the
application's
JSON-LD
context.
</p>
<p>
Consider
the
following
example:
</p>
<del class="diff-old">  {
  &quot;@context&quot;: {
    
    
</del>
  <pre class="example">
<ins class="diff-chg">{
  "@context": {
</ins>    <span class="diff">"dc": "http://purl.org/dc/elements/1.1/",</span>    <span class="diff">"ex": "http://example.org/vocab#"</span>
  },
<del class="diff-old">  &quot;@subject&quot;: &quot;http://example.org/library&quot;,
  &quot;@type&quot;: ,
  : {
    &quot;@subject&quot;: &quot;http://example.org/library/the-republic&quot;,
    &quot;@type&quot;: ,
    : &quot;Plato&quot;,
    : &quot;The Republic&quot;,
    : {
      &quot;@subject&quot;: &quot;http://example.org/library/the-republic#introduction&quot;,
      &quot;@type&quot;: ,
      : &quot;An introductory chapter on The Republic.&quot;,
      : &quot;The Introduction&quot;
</del>
<ins class="diff-chg">  "@subject": "http://example.org/library",
  "@type": <span class="diff">"ex:Library"</span>,
</ins>  <span class="diff">"ex:contains"</span>: {<ins class="diff-chg">
    "@subject": "http://example.org/library/the-republic",
    "@type": <span class="diff">"ex:Book"</span>,
</ins>    <span class="diff">"dc:creator"</span>: "Plato",    <span class="diff">"dc:title"</span>: "The Republic",    <span class="diff">"ex:contains"</span>: {<ins class="diff-chg">
      "@subject": "http://example.org/library/the-republic#introduction",
      "@type": <span class="diff">"ex:Chapter"</span>,
</ins>      <span class="diff">"dc:description"</span>: "An introductory chapter on The Republic.",      <span class="diff">"dc:title"</span>: "The Introduction"
    },
  },
}
</pre>
<p>
In
this
example,
two
different
vocabularies
are
referred
to
using
prefixes.
Those
prefixes
are
then
used
as
type
and
property
values
using
the
<code>
prefix:term
</code>
notation.
</p>
<p>
Prefixes,
also
known
as
CURIEs,
are
defined
more
formally
in
RDFa
Core
1.1,
<cite>
<a href="http://www.w3.org/TR/rdfa-core/#s_curies">
Section
6
<del class="diff-old">&quot;CURIE
</del>
<ins class="diff-chg">"CURIE
</ins>
Syntax
<del class="diff-old">Definition&quot;
</del>
<ins class="diff-chg">Definition"
</ins>
</a>
</cite>
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">
RDFA-CORE
</a>
</cite>
].
JSON-LD
does
not
support
the
square-bracketed
CURIE
syntax
as
the
mechanism
is
not
required
to
disambiguate
IRIs
in
a
JSON-LD
document
like
it
is
in
HTML
documents.
</p>
</div>
<div id="automatic-typing" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.3
</del>
<ins class="diff-chg">4.2
</ins>
</span>
Automatic
Typing
</h3>
<p>
Since
JSON
is
capable
of
expressing
typed
information
such
as
doubles,
integers,
and
boolean
values.
As
demonstrated
below,
JSON-LD
utilizes
that
information
to
create
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
s:
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
  // The following two values are automatically converted to a type of xsd:double
  // and both values are equivalent to each other.
<del class="diff-old">  &quot;measure:cups&quot;: ,
  &quot;measure:cups&quot;: ,
</del>
<ins class="diff-chg">  "measure:cups": <span class="diff">5.3</span>,
  "measure:cups": <span class="diff">5.3e0</span>,
</ins>
  // The following value is automatically converted to a type of xsd:double as well
<del class="diff-old">  &quot;space:astronomicUnits&quot;: ,
</del>
<ins class="diff-chg">  "space:astronomicUnits": <span class="diff">6.5e73</span>,
</ins>
  // The following value should never be converted to a language-native type
<del class="diff-old">  &quot;measure:stones&quot;: ,
</del>
<ins class="diff-chg">  "measure:stones": <span class="diff">{ "@literal": "4.8", "@datatype": "xsd:decimal" }</span>,
</ins>
  // This value is automatically converted to having a type of xsd:integer
<del class="diff-old">  &quot;chem:protons&quot;: ,
</del>
<ins class="diff-chg">  "chem:protons": <span class="diff">12</span>,
</ins>
  // This value is automatically converted to having a type of xsd:boolean
<del class="diff-old">  &quot;sensor:active&quot;: ,
</del>
<ins class="diff-chg">  "sensor:active": <span class="diff">true</span>,
</ins>
...
}
</pre>
<p class="note">
When
dealing
with
a
number
of
modern
programming
languages,
including
JavaScript
ECMA-262,
there
is
no
distinction
between
<strong>
xsd:decimal
</strong>
and
<strong>
xsd:double
</strong>
values.
That
is,
the
<a class="tref internalDFN" title="number" href="#dfn-number">
number
</a>
<code>
5.3
</code>
and
the
<a class="tref internalDFN" title="number" href="#dfn-number">
number
</a>
<code>
5.3e0
</code>
are
treated
as
if
they
were
the
same.
When
converting
from
JSON-LD
to
a
language-native
format
and
back,
datatype
information
is
lost
in
a
number
of
these
languages.
Thus,
one
could
say
that
<code>
5.3
</code>
is
a
<strong>
xsd:decimal
</strong>
and
<code>
5.3e0
</code>
is
an
<strong>
xsd:double
</strong>
in
JSON-LD,
but
when
both
values
are
converted
to
a
language-native
format
the
datatype
difference
between
the
two
is
lost
because
the
machine-level
representation
will
almost
always
be
a
<strong>
double
</strong>.
Implementers
should
be
aware
of
this
potential
round-tripping
issue
between
<strong>
xsd:decimal
</strong>
and
<strong>
xsd:double
</strong>.
Specifically
objects
with
a
datatype
of
<strong>
xsd:decimal
</strong>
<em class="rfc2119" title="must not">
must
not
</em>
be
converted
to
a
language
native
type.
</p>
</div>
<div id="type-coercion" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.4
</del>
<ins class="diff-chg">4.3
</ins>
</span>
Type
Coercion
</h3>
<p>
JSON-LD
supports
the
coercion
of
values
to
particular
data
types.
Type
coercion
allows
someone
deploying
JSON-LD
to
coerce
the
incoming
or
outgoing
types
to
the
proper
data
type
based
on
a
mapping
of
data
type
IRIs
to
property
types.
Using
type
coercion,
one
may
convert
simple
JSON
data
to
properly
typed
RDF
data.
</p>
<p>
The
example
below
demonstrates
how
a
JSON-LD
author
can
coerce
values
to
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>
s,
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
s
and
IRIs.
</p>
<del class="diff-old">{
  &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
  "@context":
</ins>
  {
<del class="diff-old">     &quot;rdf&quot;: &quot;http://www.w3.org/1999/02/22-rdf-syntax-ns#&quot;,
     &quot;xsd&quot;: &quot;http://www.w3.org/2001/XMLSchema#&quot;,
     &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
     &quot;age&quot;: &quot;http://xmlns.com/foaf/0.1/age&quot;,
     &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
     &quot;@coerce&quot;:
</del>
<ins class="diff-chg">     "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     "xsd": "http://www.w3.org/2001/XMLSchema#",
     "name": "http://xmlns.com/foaf/0.1/name",
     "age": "http://xmlns.com/foaf/0.1/age",
     "homepage": "http://xmlns.com/foaf/0.1/homepage",
</ins><span class="diff">     "@coerce":
     {
<del class="diff-old">        &quot;xsd:integer&quot;: &quot;age&quot;,
        &quot;@iri&quot;: &quot;homepage&quot;
</del>
<ins class="diff-chg">        "xsd:integer": "age",
        "@iri": "homepage"
</ins>
     }</span>
  },
<del class="diff-old">  &quot;name&quot;: &quot;John Smith&quot;,
  &quot;age&quot;: ,
  &quot;homepage&quot;: 
</del>
<ins class="diff-chg">  "name": "John Smith",
  "age": <span class="diff">"41"</span>,
  "homepage": <span class="diff">"http://example.org/home/"</span>
</ins>
}
</pre>
<p>
The
example
above
would
generate
the
following
triples:
</p>
<del class="diff-old">_:bnode1
</del>
<pre class="example">
<ins class="diff-chg">_:bnode1
</ins>
   &lt;http://xmlns.com/foaf/0.1/name&gt;
<del class="diff-old">      &quot;John Smith&quot; .
</del>
<ins class="diff-chg">      "John Smith" .
</ins>
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/age&gt;
<del class="diff-old">      &quot;41&quot;^^http://www.w3.org/2001/XMLSchema#integer .
</del>
<ins class="diff-chg">      "41"^^http://www.w3.org/2001/XMLSchema#integer .
</ins>
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/homepage&gt;
&lt;http://example.org/home/&gt;
.
</pre>
</div>
<div id="chaining" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.5
</del>
<ins class="diff-chg">4.4
</ins>
</span>
Chaining
</h3>
<p>
Object
<dfn title="chaining" id="dfn-chaining">
chaining
</dfn>
is
a
JSON-LD
feature
that
allows
an
author
to
use
the
definition
of
JSON-LD
objects
as
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>
values.
This
is
a
commonly
used
mechanism
for
creating
a
parent-child
relationship
between
two
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>
s.
</p>
<p>
The
example
shows
an
two
subjects
related
by
a
property
from
the
first
subject:
</p>
<del class="diff-old">  {
</del>
  <pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;&quot;: {
    &quot;&quot;,
    &quot;&quot;,
</del>
<ins class="diff-chg">  "name": "Manu Sporny",
  "<span class="diff">knows</span>": {
    "<span class="diff">@type</span>": "<span class="diff">Person</span>",
    "<span class="diff">name</span>": "<span class="diff">Gregg Kellogg</span>",
</ins>
  }
...
}
</pre>
<p>
An
object
definition,
like
the
one
used
above,
<em class="rfc2119" title="may">
may
</em>
be
used
as
a
JSON
value
at
any
point
in
JSON-LD.
</p>
</div>
<div id="identifying-unlabeled-nodes" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.6
</del>
<ins class="diff-chg">4.5
</ins>
</span>
Identifying
Unlabeled
Nodes
</h3>
<p>
At
times,
it
becomes
necessary
to
be
able
to
express
information
without
being
able
to
specify
the
subject.
Typically,
this
type
of
node
is
called
an
unlabeled
node
or
a
blank
node.
In
JSON-LD,
unlabeled
node
identifiers
are
automatically
created
if
a
subject
is
not
specified
using
the
<code>
@subject
</code>
keyword.
However,
authors
may
provide
identifiers
for
unlabeled
nodes
by
using
the
special
<code>
_
</code>
(underscore)
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>.
This
allows
to
reference
the
node
locally
within
the
document
but
not
in
an
external
document.
</p>
<del class="diff-old">{
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>
...
<del class="diff-old">  &quot;@subject&quot;: &quot;&quot;,
</del>
<ins class="diff-chg">  "@subject": "<span class="diff">_:foo</span>",
</ins>
...
}
</pre>
<p>
The
example
above
would
set
the
subject
to
<code>
_:foo
</code>,
which
can
then
be
used
later
on
in
the
JSON-LD
markup
to
refer
back
to
the
unlabeled
node.
This
practice,
however,
is
usually
frowned
upon
when
generating
Linked
Data.
If
a
developer
finds
that
they
refer
to
the
unlabeled
node
more
than
once,
they
should
consider
naming
the
node
using
a
resolve-able
IRI.
</p>
</div>
<div id="aliasing-keywords" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.7
</del>
<ins class="diff-chg">4.6
</ins>
</span>
Aliasing
Keywords
</h3>
<p>
JSON-LD
allows
all
of
the
syntax
keywords,
except
for
<code>
@context
</code>,
to
be
aliased.
This
feature
allows
more
legacy
JSON
content
to
be
supported
by
JSON-LD.
It
also
allows
developers
to
design
domain-specific
implementations
using
only
the
JSON-LD
context.
</p>
<del class="diff-old">{
  &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
  "@context":
</ins>
  {
<del class="diff-old">     ,
     ,
     &quot;name&quot;: &quot;http://schema.org/name&quot;
</del>
     <span class="diff">"url": "@subject"</span>,
     <span class="diff">"a": "@type"</span>,
<ins class="diff-chg">     "name": "http://schema.org/name"
</ins>
  },
<del class="diff-old">  &quot;url&quot;: &quot;http://example.com/about#gregg&quot;,
  &quot;a&quot;: &quot;http://schema.org/Person&quot;,
  &quot;name&quot;: &quot;Gregg Kellogg&quot;
</del>
<ins class="diff-chg">  "url": "http://example.com/about#gregg",
  "a": "http://schema.org/Person",
  "name": "Gregg Kellogg"
</ins>
}
</pre>
<p>
In
the
example
above,
the
<code>
@subject
</code>
and
<code>
@type
</code>
keywords
have
been
given
the
aliases
<strong>
url
</strong>
and
<strong>
a
</strong>,
respectively.
</p>
</div>
<div id="normalization" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.8
</del>
<ins class="diff-chg">4.7
</ins>
</span>
Normalization
</h3>
<p>
Normalization
is
the
process
of
taking
<a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>
and
performing
a
deterministic
transformation
on
that
input
that
results
in
a
<a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>
that
any
conforming
JSON-LD
processor
would
have
generated
given
the
same
input.
The
problem
is
a
fairly
difficult
technical
problem
to
solve
because
it
requires
a
directed
graph
to
be
ordered
into
a
set
of
nodes
and
edges
in
a
deterministic
way.
This
is
easy
to
do
when
all
of
the
nodes
have
unique
names,
but
very
difficult
to
do
when
some
of
the
nodes
are
not
labeled.
</p>
<p>
Normalization
is
useful
when
comparing
two
graphs
against
one
another,
when
generating
a
detailed
list
of
differences
between
two
graphs,
and
when
generating
a
cryptographic
digital
signature
for
information
contained
in
a
graph
or
when
generating
a
hash
of
the
information
contained
in
a
graph.
</p>
<p>
The
example
below
is
an
un-normalized
JSON-LD
document:
</p>
<del class="diff-old">{
   &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
   "@context":
</ins>
   {
<del class="diff-old">      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;xsd&quot;: &quot;http://www.w3.org/2001/XMLSchema#&quot;,
      &quot;@coerce&quot;:
</del>
<ins class="diff-chg">      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "xsd": "http://www.w3.org/2001/XMLSchema#",
      "@coerce":
</ins>
      {
<del class="diff-old">         &quot;@iri&quot;: [&quot;homepage&quot;]
</del>
<ins class="diff-chg">         "@iri": ["homepage"]
</ins>
      }
   },
<del class="diff-old">   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<ins class="diff-chg">   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/"
</ins>
}
</pre>
<p>
The
example
below
is
the
normalized
form
of
the
JSON-LD
document
above:
</p>
<p class="note">
Whitespace
is
used
below
to
aid
readability.
The
normalization
algorithm
for
JSON-LD
removes
all
unnecessary
whitespace
in
the
fully
normalized
form.
</p>
<del class="diff-old">[{
    &quot;@subject&quot;:
</del>
<pre class="example">
<ins class="diff-chg">[{
    "@subject":
</ins>
    {
<del class="diff-old">        &quot;@iri&quot;: &quot;_:c14n0&quot;
</del>
<ins class="diff-chg">        "@iri": "_:c14n0"
</ins>
    },
<del class="diff-old">    &quot;http://xmlns.com/foaf/0.1/homepage&quot;:
</del>
<ins class="diff-chg">    "http://xmlns.com/foaf/0.1/homepage":
</ins>
    {
<del class="diff-old">        &quot;@iri&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<ins class="diff-chg">        "@iri": "http://manu.sporny.org/"
</ins>
    },
<del class="diff-old">    &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;
</del>
<ins class="diff-chg">    "http://xmlns.com/foaf/0.1/name": "Manu Sporny"
</ins>
}]
</pre>
<p>
Notice
how
all
of
the
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
have
been
expanded
and
sorted
in
alphabetical
order.
Also,
notice
how
the
<a class="tref internalDFN" title="subject" href="#dfn-subject-1">
subject
</a>
has
been
labeled
with
a
<a class="tref internalDFN" title="blank_node_identifier" href="#dfn-blank_node_identifier-7">
blank
node
identifier
</a>.
Normalization
ensures
that
any
arbitrary
graph
containing
exactly
the
same
information
would
be
normalized
to
exactly
the
same
form
shown
above.
</p>
</div>
</div>
<div id="the-application-programming-interface" class="section">
<h2>
<span class="secno">
<ins class="diff-chg">5.
</ins></span><ins class="diff-chg">
The
Application
Programming
Interface
</ins></h2><p><ins class="diff-chg">
This
API
provides
a
clean
mechanism
that
enables
developers
to
convert
JSON-LD
data
into
a
a
variety
of
output
formats
that
are
easier
to
work
with
in
various
programming
languages.
If
a
JSON-LD
API
is
provided
in
a
programming
environment,
the
entirety
of
the
following
API
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
implemented.
</ins></p><div id="jsonldprocessor" class="section"><h3><span class="secno"><ins class="diff-chg">
5.1
</ins></span><ins class="diff-chg">
JsonLdProcessor
</ins></h3><pre class="idl"><span class="idlInterface" id="idl-def-JsonLdProcessor">[<span class="extAttr">NoInterfaceObject</span>]<ins class="diff-chg">
interface <span class="idlInterfaceID">JsonLdProcessor</span> {
</ins><span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-expand-object-object-input-object-context">expand</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>);</span><span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-compact-object-object-input-object-context">compact</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>, <span class="idlRaises"><a>ProcessingError</a></span>);</span><span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-frame-object-object-input-object-frame-object-options">frame</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">frame</span></span>, <span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">options</span></span>) raises (<span class="idlRaises"><a>InvalidFrame</a></span>);</span><span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-normalize-object-object-input-object-context">normalize</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>);</span><span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-triples-object-object-input-JsonLdTripleCallback-tripleCallback-object-context">triples</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdTripleCallback" class="idlType"><code>JsonLdTripleCallback</code></a></span> <span class="idlParamName">tripleCallback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>);</span><ins class="diff-chg">
};</span>
</ins></pre><div id="methods" class="section"><h4><span class="secno"><ins class="diff-chg">
5.1.1
</ins></span><ins class="diff-chg">
Methods
</ins></h4><dl class="methods"><dt id="widl-JsonLdProcessor-compact-object-object-input-object-context"><code><ins class="diff-chg">
compact
</ins></code></dt><dd><a href="#compaction"><ins class="diff-chg">
Compacts
</ins></a><ins class="diff-chg">
the
given
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#compaction-algorithm"><ins class="diff-chg">
Compaction
Algorithm
</ins></a>.<ins class="diff-chg">
The
</ins><code><ins class="diff-chg">
input
</ins></code><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
copied,
compacted
and
returned
if
there
are
no
errors.
If
the
compaction
fails,
an
appropirate
exception
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
thrown.
</ins><table class="parameters"><tr><th><ins class="diff-chg">
Parameter
</ins></th><th><ins class="diff-chg">
Type
</ins></th><th><ins class="diff-chg">
Nullable
</ins></th><th><ins class="diff-chg">
Optional
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="prmName"><ins class="diff-chg">
input
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
JSON-LD
object
to
perform
compaction
on.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
context
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmOptTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
base
context
to
use
when
compacting
the
</ins><code><ins class="diff-chg">
input
</ins></code>.</td></tr></table><table class="exceptions"><tr><th><ins class="diff-chg">
Exception
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="excName"><a><ins class="diff-chg">
InvalidContext
</ins></a></td><td class="excDesc"><table class="exceptionCodes"><tr><td class="excCodeName"><code><ins class="diff-chg">
INVALID_SYNTAX
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
A
general
syntax
error
was
detected
in
the
</ins><code><ins class="diff-chg">
@context
</ins></code>.<ins class="diff-chg">
For
example,
if
a
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
key
maps
to
anything
other
than
a
string
or
an
array
of
strings,
this
exception
would
be
raised.
</ins></td></tr><tr><td class="excCodeName"><code><ins class="diff-chg">
MULTIPLE_DATATYPES
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
There
is
more
than
one
target
datatype
specified
for
a
single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
a
property.
</ins></td></tr></table></td></tr><tr><td class="excName"><a><ins class="diff-chg">
ProcessingError
</ins></a></td><td class="excDesc"><table class="exceptionCodes"><tr><td class="excCodeName"><code><ins class="diff-chg">
LOSSY_COMPACTION
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
The
compaction
would
lead
to
a
loss
of
information,
such
as
a
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
value.
</ins></td></tr><tr><td class="excCodeName"><code><ins class="diff-chg">
CONFLICTING_DATATYPES
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
The
target
datatype
specified
in
the
coercion
rule
and
the
datatype
for
the
typed
literal
do
not
match.
</ins></td></tr></table></td></tr></table><div><em><ins class="diff-chg">
Return
type:
</ins></em><code><a><ins class="diff-chg">
object
</ins></a></code></div></dd><dt id="widl-JsonLdProcessor-expand-object-object-input-object-context"><code><ins class="diff-chg">
expand
</ins></code></dt><dd><a href="#expansion"><ins class="diff-chg">
Expands
</ins></a><ins class="diff-chg">
the
given
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a>.<ins class="diff-chg">
The
</ins><code><ins class="diff-chg">
input
</ins></code><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
copied,
expanded
and
returned
if
there
are
no
errors.
If
the
expansion
fails,
an
appropriate
exception
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
thrown.
</ins><table class="parameters"><tr><th><ins class="diff-chg">
Parameter
</ins></th><th><ins class="diff-chg">
Type
</ins></th><th><ins class="diff-chg">
Nullable
</ins></th><th><ins class="diff-chg">
Optional
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="prmName"><ins class="diff-chg">
input
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
JSON-LD
object
to
copy
and
perform
the
expansion
upon.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
context
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmOptTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmDesc"><ins class="diff-chg">
An
external
context
to
use
additionally
to
the
context
embedded
in
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
when
expanding
the
</ins><code><ins class="diff-chg">
input
</ins></code>.</td></tr></table><table class="exceptions"><tr><th><ins class="diff-chg">
Exception
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="excName"><a><ins class="diff-chg">
InvalidContext
</ins></a></td><td class="excDesc"><table class="exceptionCodes"><tr><td class="excCodeName"><code><ins class="diff-chg">
INVALID_SYNTAX
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
A
general
syntax
error
was
detected
in
the
</ins><code><ins class="diff-chg">
@context
</ins></code>.<ins class="diff-chg">
For
example,
if
a
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
key
maps
to
anything
other
than
a
string
or
an
array
of
strings,
this
exception
would
be
raised.
</ins></td></tr><tr><td class="excCodeName"><code><ins class="diff-chg">
MULTIPLE_DATATYPES
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
There
is
more
than
one
target
datatype
specified
for
a
single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
a
property.
</ins></td></tr></table></td></tr></table><div><em><ins class="diff-chg">
Return
type:
</ins></em><code><a><ins class="diff-chg">
object
</ins></a></code></div></dd><dt id="widl-JsonLdProcessor-frame-object-object-input-object-frame-object-options"><code><ins class="diff-chg">
frame
</ins></code></dt><dd><a href="#framing"><ins class="diff-chg">
Frames
</ins></a><ins class="diff-chg">
the
given
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
using
the
</ins><code><ins class="diff-chg">
frame
</ins></code><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#framing-algorithm"><ins class="diff-chg">
Framing
Algorithm
</ins></a>.<ins class="diff-chg">
The
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
is
used
to
build
the
framed
output
and
is
returned
if
there
are
no
errors.
If
there
are
no
matches
for
the
frame,
</ins><code><ins class="diff-chg">
null
</ins></code><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
returned.
Exceptions
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
thrown
if
there
are
errors.
</ins><table class="parameters"><tr><th><ins class="diff-chg">
Parameter
</ins></th><th><ins class="diff-chg">
Type
</ins></th><th><ins class="diff-chg">
Nullable
</ins></th><th><ins class="diff-chg">
Optional
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="prmName"><ins class="diff-chg">
input
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
JSON-LD
object
to
perform
framing
on.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
frame
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
frame
to
use
when
re-arranging
the
data.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
options
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
A
set
of
options
that
will
affect
the
framing
algorithm.
</ins></td></tr></table><table class="exceptions"><tr><th><ins class="diff-chg">
Exception
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="excName"><a><ins class="diff-chg">
InvalidFrame
</ins></a></td><td class="excDesc"><table class="exceptionCodes"><tr><td class="excCodeName"><code><ins class="diff-chg">
INVALID_SYNTAX
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
A
frame
must
be
either
an
object
or
an
array
of
objects,
if
the
frame
is
neither
of
these
types,
this
exception
is
thrown.
</ins></td></tr><tr><td class="excCodeName"><code><ins class="diff-chg">
MULTIPLE_EMBEDS
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
A
subject
IRI
was
specified
in
more
than
one
place
in
the
input
frame.
More
than
one
embed
of
a
given
subject
IRI
is
not
allowed,
and
if
requested,
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
result
in
this
exception.
</ins></td></tr></table></td></tr></table><div><em><ins class="diff-chg">
Return
type:
</ins></em><code><a><ins class="diff-chg">
object
</ins></a></code></div></dd><dt id="widl-JsonLdProcessor-normalize-object-object-input-object-context"><code><ins class="diff-chg">
normalize
</ins></code></dt><dd><a href="#normalization"><ins class="diff-chg">
Normalizes
</ins></a><ins class="diff-chg">
the
given
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#normalization-algorithm"><ins class="diff-chg">
Normalization
Algorithm
</ins></a>.<ins class="diff-chg">
The
</ins><code><ins class="diff-chg">
input
</ins></code><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
copied,
normalized
and
returned
if
there
are
no
errors.
If
the
compaction
fails,
</ins><code><ins class="diff-chg">
null
</ins></code><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
returned.
</ins><table class="parameters"><tr><th><ins class="diff-chg">
Parameter
</ins></th><th><ins class="diff-chg">
Type
</ins></th><th><ins class="diff-chg">
Nullable
</ins></th><th><ins class="diff-chg">
Optional
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="prmName"><ins class="diff-chg">
input
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
JSON-LD
object
to
perform
normalization
upon.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
context
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmOptTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmDesc"><ins class="diff-chg">
An
external
context
to
use
additionally
to
the
context
embedded
in
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
when
expanding
the
</ins><code><ins class="diff-chg">
input
</ins></code>.</td></tr></table><table class="exceptions"><tr><th><ins class="diff-chg">
Exception
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="excName"><a><ins class="diff-chg">
InvalidContext
</ins></a></td><td class="excDesc"><table class="exceptionCodes"><tr><td class="excCodeName"><code><ins class="diff-chg">
INVALID_SYNTAX
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
A
general
syntax
error
was
detected
in
the
</ins><code><ins class="diff-chg">
@context
</ins></code>.<ins class="diff-chg">
For
example,
if
a
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
key
maps
to
anything
other
than
a
string
or
an
array
of
strings,
this
exception
would
be
raised.
</ins></td></tr><tr><td class="excCodeName"><code><ins class="diff-chg">
MULTIPLE_DATATYPES
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
There
is
more
than
one
target
datatype
specified
for
a
single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
a
property.
</ins></td></tr></table></td></tr></table><div><em><ins class="diff-chg">
Return
type:
</ins></em><code><a><ins class="diff-chg">
object
</ins></a></code></div></dd><dt id="widl-JsonLdProcessor-triples-object-object-input-JsonLdTripleCallback-tripleCallback-object-context"><code><ins class="diff-chg">
triples
</ins></code></dt><dd><ins class="diff-chg">
Processes
the
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
according
to
the
</ins><a href="#rdf-conversion-algorithm"><ins class="diff-chg">
RDF
Conversion
Algorithm
</ins></a>,<ins class="diff-chg">
calling
the
provided
</ins><code><ins class="diff-chg">
tripleCallback
</ins></code><ins class="diff-chg">
for
each
triple
generated.
</ins><table class="parameters"><tr><th><ins class="diff-chg">
Parameter
</ins></th><th><ins class="diff-chg">
Type
</ins></th><th><ins class="diff-chg">
Nullable
</ins></th><th><ins class="diff-chg">
Optional
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="prmName"><ins class="diff-chg">
input
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
JSON-LD
object
to
process
when
outputting
triples.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
tripleCallback
</ins></td><td class="prmType"><code><a href="#idl-def-JsonLdTripleCallback" class="idlType"><code><ins class="diff-chg">
JsonLdTripleCallback
</ins></code></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
A
callback
that
is
called
whenever
a
processing
error
occurs
on
the
given
</ins><code><ins class="diff-chg">
input
</ins></code>.<div class="issue"><ins class="diff-chg">
This
callback
should
be
aligned
with
the
RDF
API.
</ins></div></td></tr><tr><td class="prmName"><ins class="diff-chg">
context
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
object
</ins></a></code></td><td class="prmNullTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmOptTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmDesc"><ins class="diff-chg">
An
external
context
to
use
additionally
to
the
context
embedded
in
</ins><code><ins class="diff-chg">
input
</ins></code><ins class="diff-chg">
when
expanding
the
</ins><code><ins class="diff-chg">
input
</ins></code>.</td></tr></table><table class="exceptions"><tr><th><ins class="diff-chg">
Exception
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="excName"><a><ins class="diff-chg">
InvalidContext
</ins></a></td><td class="excDesc"><table class="exceptionCodes"><tr><td class="excCodeName"><code><ins class="diff-chg">
INVALID_SYNTAX
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
A
general
syntax
error
was
detected
in
the
</ins><code><ins class="diff-chg">
@context
</ins></code>.<ins class="diff-chg">
For
example,
if
a
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
key
maps
to
anything
other
than
a
string
or
an
array
of
strings,
this
exception
would
be
raised.
</ins></td></tr><tr><td class="excCodeName"><code><ins class="diff-chg">
MULTIPLE_DATATYPES
</ins></code></td><td class="excCodeDesc"><ins class="diff-chg">
There
is
more
than
one
target
datatype
specified
for
a
single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
a
property.
</ins></td></tr></table></td></tr></table><div><em><ins class="diff-chg">
Return
type:
</ins></em><code><a><ins class="diff-chg">
object
</ins></a></code></div></dd></dl></div></div><div id="jsonldtriplecallback" class="section"><h3><span class="secno"><ins class="diff-chg">
5.2
</ins></span><ins class="diff-chg">
JsonLdTripleCallback
</ins></h3><p><ins class="diff-chg">
The
JsonLdTripleCallback
is
called
whenever
the
processor
generates
a
triple
during
the
</ins><code><ins class="diff-chg">
triple()
</ins></code><ins class="diff-chg">
call.
</ins></p><pre class="idl"><span class="idlInterface" id="idl-def-JsonLdTripleCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]<ins class="diff-chg">
interface <span class="idlInterfaceID">JsonLdTripleCallback</span> {
</ins><span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdTripleCallback-triple-void-DOMString-subject-DOMString-property-DOMString-objectType-DOMString-object-DOMString-datatype-DOMString-language">triple</a></span> (<span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">subject</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">property</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">objectType</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">object</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a>?</span> <span class="idlParamName">datatype</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a>?</span> <span class="idlParamName">language</span></span>);</span><ins class="diff-chg">
};</span>
</ins></pre><div id="methods-1" class="section"><h4><span class="secno"><ins class="diff-chg">
5.2.1
</ins></span><ins class="diff-chg">
Methods
</ins></h4><dl class="methods"><dt id="widl-JsonLdTripleCallback-triple-void-DOMString-subject-DOMString-property-DOMString-objectType-DOMString-object-DOMString-datatype-DOMString-language"><code><ins class="diff-chg">
triple
</ins></code></dt><dd><ins class="diff-chg">
This
callback
is
invoked
whenever
a
triple
is
generated
by
the
processor.
</ins><table class="parameters"><tr><th><ins class="diff-chg">
Parameter
</ins></th><th><ins class="diff-chg">
Type
</ins></th><th><ins class="diff-chg">
Nullable
</ins></th><th><ins class="diff-chg">
Optional
</ins></th><th><ins class="diff-chg">
Description
</ins></th></tr><tr><td class="prmName"><ins class="diff-chg">
subject
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
DOMString
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
subject
IRI
that
is
associated
with
the
triple.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
property
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
DOMString
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
property
IRI
that
is
associated
with
the
triple.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
objectType
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
DOMString
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
type
of
object
that
is
associated
with
the
triple.
Valid
values
are
</ins><code><ins class="diff-chg">
IRI
</ins></code><ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
literal
</ins></code>.</td></tr><tr><td class="prmName"><ins class="diff-chg">
object
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
DOMString
</ins></a></code></td><td class="prmNullFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
object
value
associated
with
the
subject
and
the
property.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
datatype
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
DOMString
</ins></a></code></td><td class="prmNullTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
datatype
associated
with
the
object.
</ins></td></tr><tr><td class="prmName"><ins class="diff-chg">
language
</ins></td><td class="prmType"><code><a><ins class="diff-chg">
DOMString
</ins></a></code></td><td class="prmNullTrue"><ins class="diff-chg">
✔
</ins></td><td class="prmOptFalse"><ins class="diff-chg">
✘
</ins></td><td class="prmDesc"><ins class="diff-chg">
The
language
associated
with
the
object
in
BCP47
format.
</ins></td></tr></table><div><em><ins class="diff-chg">
No
exceptions.
</ins></em></div><div><em><ins class="diff-chg">
Return
type:
</ins></em><code><a><ins class="diff-chg">
void
</ins></a></code></div></dd></dl></div></div></div><div id="algorithms" class="section"><h2><span class="secno"><ins class="diff-chg">
6.
</ins></span><ins class="diff-chg">
Algorithms
</ins></h2><p><ins class="diff-chg">
All
algorithms
described
in
this
section
are
intended
to
operate
on
language-native
data
structures.
That
is,
the
serialization
to
a
text-based
JSON
document
isn't
required
as
input
or
output
to
any
of
these
algorithms
and
language-native
data
structures
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
used
where
applicable.
</ins></p><div id="syntax-tokens-and-keywords" class="section"><h3><span class="secno"><ins class="diff-chg">
6.1
</ins></span><ins class="diff-chg">
Syntax
Tokens
and
Keywords
</ins></h3><p><ins class="diff-chg">
JSON-LD
specifies
a
number
of
syntax
tokens
and
keywords
that
are
using
in
all
algorithms
described
in
this
section:
</ins></p><dl><dt><code><ins class="diff-chg">
@context
</ins></code></dt><dd><ins class="diff-chg">
Used
to
set
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a>.</dd><dt><code><ins class="diff-chg">
@base
</ins></code></dt><dd><ins class="diff-chg">
Used
to
set
the
base
IRI
for
all
object
IRIs
affected
by
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.</dd><dt><code><ins class="diff-chg">
@vocab
</ins></code></dt><dd><ins class="diff-chg">
Used
to
set
the
base
IRI
for
all
property
IRIs
affected
by
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.</dd><dt><code><ins class="diff-chg">
@coerce
</ins></code></dt><dd><ins class="diff-chg">
Used
to
specify
type
coercion
rules.
</ins></dd><dt><code><ins class="diff-chg">
@literal
</ins></code></dt><dd><ins class="diff-chg">
Used
to
specify
a
literal
value.
</ins></dd><dt><code><ins class="diff-chg">
@iri
</ins></code></dt><dd><ins class="diff-chg">
Used
to
specify
an
IRI
value.
</ins></dd><dt><code><ins class="diff-chg">
@language
</ins></code></dt><dd><ins class="diff-chg">
Used
to
specify
the
language
for
a
literal.
</ins></dd><dt><code><ins class="diff-chg">
@datatype
</ins></code></dt><dd><ins class="diff-chg">
Used
to
specify
the
datatype
for
a
literal.
</ins></dd><dt><code>:</code></dt><dd><ins class="diff-chg">
The
separator
for
JSON
keys
and
values
that
use
the
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix-1"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
mechanism.
</ins></dd><dt><code><ins class="diff-chg">
@subject
</ins></code></dt><dd><ins class="diff-chg">
Sets
the
active
subjects.
</ins></dd><dt><code><ins class="diff-chg">
@type
</ins></code></dt><dd><ins class="diff-chg">
Used
to
set
the
type
of
the
active
subjects.
</ins></dd></dl></div><div id="algorithm-terms" class="section"><h3><span class="secno"><ins class="diff-chg">
6.2
</ins></span><ins class="diff-chg">
Algorithm
Terms
</ins></h3><dl><dt><dfn title="initial_context" id="dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
that
is
specified
to
the
algorithm
before
processing
begins.
</ins></dd><dt><dfn title="active_subject" id="dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></dfn></dt><dd><ins class="diff-chg">
the
currently
active
subject
that
the
processor
should
use
when
processing.
</ins></dd><dt><dfn title="active_property" id="dfn-active_property"><ins class="diff-chg">
active
property
</ins></dfn></dt><dd><ins class="diff-chg">
the
currently
active
property
that
the
processor
should
use
when
processing.
</ins></dd><dt><dfn title="active_object" id="dfn-active_object"><ins class="diff-chg">
active
object
</ins></dfn></dt><dd><ins class="diff-chg">
the
currently
active
object
that
the
processor
should
use
when
processing.
</ins></dd><dt><dfn title="active_context" id="dfn-active_context"><ins class="diff-chg">
active
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
that
is
used
to
resolve
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix-1"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
es
and
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s
while
the
processing
algorithm
is
running.
The
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
is
the
context
contained
within
the
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>.</dd><dt><dfn title="local_context" id="dfn-local_context"><ins class="diff-chg">
local
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
that
is
specified
within
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a>,<ins class="diff-chg">
specified
via
the
</ins><code><ins class="diff-chg">
@context
</ins></code><ins class="diff-chg">
keyword.
</ins></dd><dt><dfn title="processor_state" id="dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></dfn></dt><dd><ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>,<ins class="diff-chg">
which
includes
the
</ins><a class="tref" title="active__context"><ins class="diff-chg">
active
context
</ins></a>,<a class="tref" title="current_subject"><ins class="diff-chg">
current
subject
</ins></a>,<ins class="diff-chg">
and
</ins><a class="tref" title="current_property"><ins class="diff-chg">
current
property
</ins></a>.<ins class="diff-chg">
The
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
is
managed
as
a
stack
with
elements
from
the
previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
copied
into
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
when
entering
a
new
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a>.</dd><dt><dfn title="JSON-LD_input" id="dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></dfn></dt><dd><ins class="diff-chg">
The
JSON-LD
data
structure
that
is
provided
as
input
to
the
algorithm.
</ins></dd><dt><dfn title="JSON-LD_output" id="dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></dfn></dt><dd><ins class="diff-chg">
The
JSON-LD
data
structure
that
is
produced
as
output
by
the
algorithm.
</ins></dd></dl></div><div id="context-1" class="section"><h3 id="context"><span class="secno"><ins class="diff-chg">
6.3
</ins></span><ins class="diff-chg">
Context
</ins></h3><p><ins class="diff-chg">
Processing
of
JSON-LD
data
structure
is
managed
recursively.
During
processing,
each
rule
is
applied
using
information
provided
by
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.<ins class="diff-chg">
Processing
begins
by
pushing
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
onto
the
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
stack
and
initializing
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
with
the
</ins><a class="tref internalDFN" title="initial_context" href="#dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></a>.<ins class="diff-chg">
If
a
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
is
encountered,
information
from
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
is
merged
into
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.</p><p><ins class="diff-chg">
The
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
is
used
for
expanding
keys
and
values
of
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
(or
elements
of
a
list
(see
</ins><span a="#list-processing"><ins class="diff-chg">
List
Processing
</ins></span><ins class="diff-chg">
)).
</ins></p><p><ins class="diff-chg">
A
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
is
identified
within
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
having
a
key
of
</ins><code><ins class="diff-chg">
@context
</ins></code><ins class="diff-chg">
with
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a><ins class="diff-chg">
or
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
value.
When
processing
a
</ins><a class="tref" title="local__context"><ins class="diff-chg">
local
context
</ins></a>,<ins class="diff-chg">
special
processing
rules
apply:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Create
a
new,
empty
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a>.</li><li><ins class="diff-chg">
If
the
value
is
a
simple
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a>,<ins class="diff-chg">
it
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
a
lexical
form
of
IRI
and
used
to
initialize
a
new
JSON
document
which
replaces
the
value
for
subsequent
processing.
</ins></li><li><ins class="diff-chg">
If
the
value
is
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a>,<ins class="diff-chg">
perform
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
has
a
</ins><code><ins class="diff-chg">
@base
</ins></code><ins class="diff-chg">
key,
it
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
a
value
of
a
simple
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a><ins class="diff-chg">
with
the
lexical
form
of
an
absolute
IRI.
Add
the
base
mapping
to
the
</ins><a class="tref" title="local__context"><ins class="diff-chg">
local
context
</ins></a>.<p class="issue"><ins class="diff-chg">
Turtle
allows
@base
to
be
relative.
If
we
did
this,
we
would
have
to
add
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a>.</p></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
has
a
</ins><code><ins class="diff-chg">
@vocab
</ins></code><ins class="diff-chg">
key,
it
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
a
value
of
a
simple
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a><ins class="diff-chg">
with
the
lexical
form
of
an
absolute
IRI.
Add
the
vocabulary
mapping
to
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
after
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
associated
value.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
has
a
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
key,
it
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
a
value
of
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a>.<ins class="diff-chg">
Add
the
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
to
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
associated
value(s).
</ins></li><li><ins class="diff-chg">
Otherwise,
the
key
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
the
lexical
form
of
</ins><cite><a href="http://www.w3.org/TR/2009/REC-xml-names-20091208/#NT-NCName"><ins class="diff-chg">
NCName
</ins></a></cite><ins class="diff-chg">
and
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
the
value
of
a
simple
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a><ins class="diff-chg">
with
the
lexical
form
of
IRI.
Merge
the
key-value
pair
into
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Merge
the
of
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
's
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
into
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
's
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
as
described
</ins><a href="#coerce"><ins class="diff-chg">
below
</ins></a>.</li><li><ins class="diff-chg">
Merge
all
entries
other
than
the
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
from
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
overwriting
any
duplicate
values.
</ins></li></ol><div id="coerce" class="section"><h4><span class="secno"><ins class="diff-chg">
6.3.1
</ins></span><ins class="diff-chg">
Coerce
</ins></h4><p><ins class="diff-chg">
Map
each
key-value
pair
in
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
's
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
into
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
's
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping,
overwriting
any
duplicate
values
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
's
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping.
The
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
has
either
a
single
</ins><code><ins class="diff-chg">
prefix:term
</ins></code><ins class="diff-chg">
value,
a
single
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
value
or
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
of
</ins><code><ins class="diff-chg">
prefix:term
</ins></code><ins class="diff-chg">
or
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
values.
When
merging
with
an
existing
mapping
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>,<ins class="diff-chg">
map
all
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix-1"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
values
to
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
form
and
replace
with
the
union
of
the
value
from
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
and
the
value
of
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.<ins class="diff-chg">
If
the
result
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
with
a
single
value,
the
processor
</ins><em class="rfc2119" title="may"><ins class="diff-chg">
may
</ins></em><ins class="diff-chg">
represent
this
as
a
string
value.
</ins></p></div><div id="initial-context" class="section"><h4><span class="secno"><ins class="diff-chg">
6.3.2
</ins></span><ins class="diff-chg">
Initial
Context
</ins></h4><p><ins class="diff-chg">
The
</ins><a class="tref internalDFN" title="initial_context" href="#dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></a><ins class="diff-chg">
is
initialized
as
follows:
</ins></p><ul><li><code><ins class="diff-chg">
@base
</ins></code><ins class="diff-chg">
is
set
using
</ins><cite><href="http: www.ietf.org="" rfc="" rfc2396.txt"=""><ins class="diff-chg">
section
5.1
Establishing
a
Base
URI
</ins></href="http:></cite><ins class="diff-chg">
of
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RFC3986"><ins class="diff-chg">
RFC3986
</ins></a></cite><ins class="diff-chg">
].
Processors
</ins><em class="rfc2119" title="may"><ins class="diff-chg">
may
</ins></em><ins class="diff-chg">
provide
a
means
of
setting
the
base
IRI
programatically.
</ins></li><li><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
is
set
with
a
single
mapping
from
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
@type
</ins></code>.</li></ul>    <pre class="example"><ins class="diff-chg">
{
    "@base": <span class="diff">document-location</span>,
    "@context": {
      "@iri": "@type"
    }
}
</ins></pre></div></div><div id="iri-expansion" class="section"><h3><span class="secno"><ins class="diff-chg">
6.4
</ins></span><ins class="diff-chg">
IRI
Expansion
</ins></h3><p><ins class="diff-chg">
Keys
and
some
values
are
evaluated
to
produce
an
IRI.
This
section
defines
an
algorithm
for
transforming
a
value
representing
an
IRI
into
an
actual
IRI.
</ins></p><p><ins class="diff-chg">
IRIs
may
be
represented
as
an
absolute
IRI,
a
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a>,<ins class="diff-chg">
a
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix-1"><ins class="diff-chg">
prefix
</ins></a>:<a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
construct,
or
as
a
value
relative
to
</ins><code><ins class="diff-chg">
@base
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
@vocab
</ins></code>.</p><p><ins class="diff-chg">
The
algorithm
for
generating
an
IRI
is:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Split
the
value
into
a
</ins><em><ins class="diff-chg">
prefix
</ins></em><ins class="diff-chg">
and
</ins><em><ins class="diff-chg">
suffix
</ins></em><ins class="diff-chg">
from
the
first
occurrence
of
':'.
</ins></li><li><ins class="diff-chg">
If
the
prefix
is
a
'_'
(underscore),
the
IRI
is
unchanged.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
contains
a
mapping
for
</ins><em><ins class="diff-chg">
prefix
</ins></em>,<ins class="diff-chg">
generate
an
IRI
by
prepending
the
mapped
prefix
to
the
(possibly
empty)
suffix
using
textual
concatenation.
Note
that
an
empty
suffix
and
no
suffix
(meaning
the
value
contains
no
':'
string
at
all)
are
treated
equivalently.
</ins></li><li><ins class="diff-chg">
If
the
IRI
being
processed
is
for
a
property
(i.e.,
a
key's
value
in
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a>,<ins class="diff-chg">
or
a
value
in
a
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping)
and
the
active
context
has
a
</ins><code><ins class="diff-chg">
@vocab
</ins></code><ins class="diff-chg">
mapping,
join
the
mapped
value
to
the
suffix
using
textual
concatenation.
</ins></li><li><ins class="diff-chg">
If
the
IRI
being
processed
is
for
a
subject
or
object
(i.e.,
not
a
property)
and
the
active
context
has
a
</ins><code><ins class="diff-chg">
@base
</ins></code><ins class="diff-chg">
mapping,
join
the
mapped
value
to
the
suffix
using
the
method
described
in
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RFC3986"><ins class="diff-chg">
RFC3986
</ins></a></cite><ins class="diff-chg">
].
</ins></li><li><ins class="diff-chg">
Otherwise,
use
the
value
directly
as
an
IRI.
</ins></li></ol><p></p></div><div id="iri-compaction" class="section"><h3><span class="secno"><ins class="diff-chg">
6.5
</ins></span><ins class="diff-chg">
IRI
Compaction
</ins></h3><p><ins class="diff-chg">
Some
keys
and
values
are
expressed
using
IRIs.
This
section
defines
an
algorithm
for
transforming
an
IRI
to
a
compact
IRI
using
the
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s
and
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix-1"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
es
specified
in
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a>.</p><p><ins class="diff-chg">
The
algorithm
for
generating
a
compacted
IRI
is:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Search
every
key-value
pair
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
for
a
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
that
is
a
complete
match
against
the
IRI.
If
a
complete
match
is
found,
the
resulting
compacted
IRI
is
the
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
associated
with
the
IRI
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.</li><li><ins class="diff-chg">
If
a
complete
match
is
not
found,
search
for
a
partial
match
from
the
beginning
of
the
IRI.
For
all
matches
that
are
found,
the
resulting
compacted
IRI
is
the
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix-1"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
associated
with
the
partially
matched
IRI
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
concatenated
with
a
colon
(:)
character
and
the
unmatched
part
of
the
string.
If
there
is
more
than
one
compacted
IRI
produced,
the
final
value
is
the
shortest
and
lexicographically
least
value
of
the
entire
set
of
compacted
IRIs.
</ins></li></ol><p></p></div><div id="value-expansion" class="section"><h3><span class="secno"><ins class="diff-chg">
6.6
</ins></span><ins class="diff-chg">
Value
Expansion
</ins></h3><p><ins class="diff-chg">
Some
values
in
JSON-LD
can
be
expressed
in
a
compact
form.
These
values
are
required
to
be
expanded
at
times
when
processing
JSON-LD
documents.
</ins></p><p><ins class="diff-chg">
The
algorithm
for
expanding
a
value
is:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
the
key
that
is
associated
with
the
value
has
an
associated
coercion
entry
in
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a>,<ins class="diff-chg">
the
resulting
expansion
is
an
object
populated
according
to
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
coercion
target
is
</ins><code><ins class="diff-chg">
@iri
</ins></code>,<ins class="diff-chg">
expand
the
value
by
adding
a
new
key-value
pair
where
the
key
is
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
and
the
value
is
the
expanded
IRI
according
to
the
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
rules.
</ins></li><li><ins class="diff-chg">
If
the
coercion
target
is
a
typed
literal,
expand
the
value
by
adding
two
new
key-value
pairs.
The
first
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
and
the
unexpanded
value.
The
second
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@datatype
</ins></code><ins class="diff-chg">
and
the
associated
coercion
datatype
expanded
according
to
the
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
rules.
</ins></li></ol></li></ol><p></p></div><div id="value-compaction" class="section"><h3><span class="secno"><ins class="diff-chg">
6.7
</ins></span><ins class="diff-chg">
Value
Compaction
</ins></h3><p><ins class="diff-chg">
Some
values,
such
as
IRIs
and
typed
literals,
may
be
expressed
in
an
expanded
form
in
JSON-LD.
These
values
are
required
to
be
compacted
at
times
when
processing
JSON-LD
documents.
</ins></p><p><ins class="diff-chg">
The
algorithm
for
compacting
a
value
is:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
contains
a
coercion
target
for
the
key
that
is
associated
with
the
value,
compact
the
value
using
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
coercion
target
is
an
</ins><code><ins class="diff-chg">
@iri
</ins></code>,<ins class="diff-chg">
the
compacted
value
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
key,
processed
according
to
the
</ins><a href="#iri-compaction"><ins class="diff-chg">
IRI
Compaction
</ins></a><ins class="diff-chg">
steps.
</ins></li><li><ins class="diff-chg">
If
the
coercion
target
is
a
typed
literal,
the
compacted
value
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
key.
</ins></li><li><ins class="diff-chg">
Otherwise,
the
value
is
not
modified.
</ins></li></ol></li></ol><p></p></div><div id="expansion-1" class="section"><h3><span class="secno"><ins class="diff-chg">
6.8
</ins></span><ins class="diff-chg">
Expansion
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
As
stated
previously,
expansion
is
the
process
of
taking
a
JSON-LD
input
and
expanding
all
IRIs
and
typed
literals
to
their
fully-expanded
form.
The
output
will
not
contain
a
single
context
declaration
and
will
have
all
IRIs
and
typed
literals
fully
expanded.
</ins></p><div id="expansion-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.8.1
</ins></span><ins class="diff-chg">
Expansion
Algorithm
</ins></h4><ol class="algorithm"><li><ins class="diff-chg">
If
the
top-level
item
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
process
each
item
in
the
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
recursively
using
this
algorithm.
</ins></li><li><ins class="diff-chg">
If
the
top-level
item
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
is
an
object,
update
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
according
to
the
steps
outlined
in
the
</ins><a href="#context"><ins class="diff-chg">
context
</ins></a><ins class="diff-chg">
section.
Process
each
key,
expanding
the
key
according
to
the
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
rules.
</ins></li><ol class="algorithm"><li><ins class="diff-chg">
Process
each
value
associated
with
each
key:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
value
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
process
each
item
in
the
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
recursively
using
this
algorithm.
</ins></li><li><ins class="diff-chg">
If
the
value
is
an
object,
process
the
object
recursively
using
this
algorithm.
</ins></li><li><ins class="diff-chg">
Otherwise,
check
to
see
the
associated
key
has
an
associated
coercion
rule.
If
the
value
should
be
coerced,
expand
the
value
according
to
the
</ins><a href="#value-expansion"><ins class="diff-chg">
Value
Expansion
</ins></a><ins class="diff-chg">
rules.
If
the
value
does
not
need
to
be
coerced,
leave
the
value
as-is.
</ins></li></ol></li><li><ins class="diff-chg">
Remove
the
context
from
the
object.
</ins></li></ol></ol></div></div><div id="compaction-1" class="section"><h3><span class="secno"><ins class="diff-chg">
6.9
</ins></span><ins class="diff-chg">
Compaction
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
As
stated
previously,
compaction
is
the
process
of
taking
a
JSON-LD
input
and
compacting
all
IRIs
using
a
given
context.
The
output
will
contain
a
single
top-level
context
declaration
and
will
only
use
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s
and
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix-1"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
es
and
will
ensure
that
all
typed
literals
are
fully
compacted.
</ins></p><div id="compaction-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.9.1
</ins></span><ins class="diff-chg">
Compaction
Algorithm
</ins></h4><ol class="algorithm"><li><ins class="diff-chg">
Perform
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a><ins class="diff-chg">
on
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a>.<ins class="diff-chg">
This
removes
any
existing
context
to
allow
the
given
context
to
be
cleanly
applied.
</ins></li><li><ins class="diff-chg">
Set
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
to
the
given
context.
</ins></li><li><ins class="diff-chg">
If
the
top-level
item
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
process
each
item
in
the
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
recursively,
starting
at
this
step.
</ins></li><li><ins class="diff-chg">
If
the
top-level
item
is
an
object,
compress
each
key
using
the
steps
defined
in
</ins><a href="#iri-compaction"><ins class="diff-chg">
IRI
Compaction
</ins></a><ins class="diff-chg">
and
compress
each
value
using
the
steps
defined
in
</ins><a href="#value-compaction"><ins class="diff-chg">
Value
Compaction
</ins></a>.</li></ol></div></div><div id="framing-1" class="section"><h3><span class="secno"><ins class="diff-chg">
6.10
</ins></span><ins class="diff-chg">
Framing
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
A
JSON-LD
document
is
a
representation
of
a
directed
graph.
A
single
directed
graph
can
have
many
different
serializations,
each
expressing
exactly
the
same
information.
Developers
typically
don't
work
directly
with
graphs,
but
rather,
prefer
trees
when
dealing
with
JSON.
While
mapping
a
graph
to
a
tree
can
be
done,
the
layout
of
the
end
result
must
be
specified
in
advance.
This
section
defines
an
algorithm
for
mapping
a
graph
to
a
tree
given
a
</ins><a class="tref internalDFN" title="frame" href="#dfn-frame"><ins class="diff-chg">
frame
</ins></a>.</p><div id="framing-algorithm-terms" class="section"><h4><span class="secno"><ins class="diff-chg">
6.10.1
</ins></span><ins class="diff-chg">
Framing
Algorithm
Terms
</ins></h4><dl><dt><dfn title="input_frame" id="dfn-input_frame"><ins class="diff-chg">
input
frame
</ins></dfn></dt><dd><ins class="diff-chg">
the
initial
</ins><a class="tref internalDFN" title="frame" href="#dfn-frame"><ins class="diff-chg">
frame
</ins></a><ins class="diff-chg">
provided
to
the
framing
algorithm.
</ins></dd><dt><dfn title="framing_context" id="dfn-framing_context"><ins class="diff-chg">
framing
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
containing
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref" title="omit_default_flag"><ins class="diff-chg">
omit
default
flag
</ins></a>.</dd><dt><dfn title="object_embed_flag" id="dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></dfn></dt><dd><ins class="diff-chg">
a
flag
specifying
that
objects
should
be
directly
embedded
in
the
output,
instead
of
being
referred
to
by
their
IRI.
</ins></dd><dt><dfn title="explicit_inclusion_flag" id="dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></dfn></dt><dd><ins class="diff-chg">
a
flag
specifying
that
for
properties
to
be
included
in
the
output,
they
must
be
explicitly
declared
in
the
</ins><a class="tref internalDFN" title="framing_context" href="#dfn-framing_context"><ins class="diff-chg">
framing
context
</ins></a>.</dd><dt><dfn title="omit_missing_properties_flag" id="dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></dfn></dt><dd><ins class="diff-chg">
a
flag
specifying
that
properties
that
are
missing
from
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
should
be
omitted
from
the
output.
</ins></dd><dt><dfn title="match_limit" id="dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></dfn></dt><dd><ins class="diff-chg">
A
value
specifying
the
maximum
number
of
matches
to
accept
when
building
arrays
of
values
during
the
framing
algorithm.
A
value
of
-1
specifies
that
there
is
no
match
limit.
</ins></dd><dt><dfn title="map_of_embedded_subjects" id="dfn-map_of_embedded_subjects"><ins class="diff-chg">
map
of
embedded
subjects
</ins></dfn></dt><dd><ins class="diff-chg">
A
map
that
tracks
if
a
subject
has
been
embedded
in
the
output
of
the
</ins><a href="#framing-algorithm"><ins class="diff-chg">
Framing
Algorithm
</ins></a>.</dd></dl></div><div id="framing-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.10.2
</ins></span><ins class="diff-chg">
Framing
Algorithm
</ins></h4><p><ins class="diff-chg">
The
framing
algorithm
takes
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
that
has
been
normalized
according
to
the
</ins><a href="#normalization-algorithm"><ins class="diff-chg">
Normalization
Algorithm
</ins></a><ins class="diff-chg">
(
</ins><strong><ins class="diff-chg">
normalized
input
</ins></strong><ins class="diff-chg">
),
an
</ins><a class="tref internalDFN" title="input_frame" href="#dfn-input_frame"><ins class="diff-chg">
input
frame
</ins></a><ins class="diff-chg">
that
has
been
expanded
according
to
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a><ins class="diff-chg">
(
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
),
and
a
number
of
options
and
produces
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.<ins class="diff-chg">
The
following
series
of
steps
is
the
recursive
portion
of
the
framing
algorithm:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Initialize
the
</ins><a class="tref internalDFN" title="framing_context" href="#dfn-framing_context"><ins class="diff-chg">
framing
context
</ins></a><ins class="diff-chg">
by
setting
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a>,<ins class="diff-chg">
clearing
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a>,<ins class="diff-chg">
and
clearing
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a>.<ins class="diff-chg">
Override
these
values
based
on
input
options
provided
to
the
algorithm
by
the
application.
</ins></li><li><ins class="diff-chg">
Generate
a
</ins><dfn title="list_of_frames" id="dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></dfn><ins class="diff-chg">
by
processing
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
not
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
set
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
to
1,
place
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
into
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a>,<ins class="diff-chg">
and
set
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
null
</ins></code>.</li><li><ins class="diff-chg">
If
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
an
empty
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
place
an
empty
object
into
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a>,<ins class="diff-chg">
set
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
and
set
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
to
-1.
</ins></li><li><ins class="diff-chg">
If
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
a
non-empty
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
add
each
item
in
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
into
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a>,<ins class="diff-chg">
set
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
and
set
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
to
-1.
</ins></li></ol></li><li><ins class="diff-chg">
Create
a
</ins><dfn title="match_array" id="dfn-match_array"><ins class="diff-chg">
match
array
</ins></dfn><ins class="diff-chg">
for
each
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a><ins class="diff-chg">
halting
when
either
the
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
is
zero
or
the
end
of
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a><ins class="diff-chg">
is
reached.
If
an
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
not
an
object,
the
processor
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
throw
a
</ins><code><ins class="diff-chg">
Invalid
Frame
Format
</ins></code><ins class="diff-chg">
exception.
Add
each
matching
item
from
the
</ins><strong><ins class="diff-chg">
normalized
input
</ins></strong><ins class="diff-chg">
to
the
</ins><a class="tref" title="matches_array"><ins class="diff-chg">
matches
array
</ins></a><ins class="diff-chg">
and
decrement
the
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
by
1
if:
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
has
an
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
that
exists
in
the
item's
list
of
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
s.
Note:
the
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
can
be
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
but
only
one
value
needs
to
be
in
common
between
the
item
and
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
for
a
match.
</ins></li><li><ins class="diff-chg">
The
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
does
not
have
an
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
property,
but
every
property
in
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
exists
in
the
item.
</ins></li></ol></li><li><ins class="diff-chg">
Process
each
item
in
the
</ins><a class="tref internalDFN" title="match_array" href="#dfn-match_array"><ins class="diff-chg">
match
array
</ins></a><ins class="diff-chg">
with
its
associated
</ins><dfn title="match_frame" id="dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></dfn>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
contains
an
</ins><code><ins class="diff-chg">
@embed
</ins></code><ins class="diff-chg">
keyword,
set
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
to
its
value.
If
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
contains
an
</ins><code><ins class="diff-chg">
@explicit
</ins></code><ins class="diff-chg">
keyword,
set
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a><ins class="diff-chg">
to
its
value.
Note:
if
the
keyword
exists,
but
the
value
is
neither
</ins><code><ins class="diff-chg">
true
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
false
</ins></code>,<ins class="diff-chg">
set
the
associated
flag
to
</ins><code><ins class="diff-chg">
true
</ins></code>.</li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
is
cleared
and
the
item
has
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property,
replace
the
item
with
the
value
of
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
is
set
and
the
item
has
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property,
and
its
IRI
is
in
the
</ins><a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects"><ins class="diff-chg">
map
of
embedded
subjects
</ins></a>,<ins class="diff-chg">
throw
a
</ins><code><ins class="diff-chg">
Duplicate
Embed
</ins></code><ins class="diff-chg">
exception.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
is
set
and
the
item
has
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property
and
its
IRI
is
not
in
the
</ins><a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects"><ins class="diff-chg">
map
of
embedded
subjects
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a><ins class="diff-chg">
is
set,
then
delete
any
key
from
the
item
that
does
not
exist
in
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a>,<ins class="diff-chg">
except
</ins><code><ins class="diff-chg">
@subject
</ins></code>.</li><li><ins class="diff-chg">
For
each
key
in
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a>,<ins class="diff-chg">
except
for
keywords
and
</ins><code><ins class="diff-chg">
rdf:type
</ins></code>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
key
is
in
the
item,
then
build
a
new
</ins><dfn title="recursion_input_list" id="dfn-recursion_input_list"><ins class="diff-chg">
recursion
input
list
</ins></dfn><ins class="diff-chg">
using
the
object
or
objects
associated
with
the
key.
If
any
object
contains
an
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
value
that
exists
in
the
</ins><a class="tref" title="normalized_input"><ins class="diff-chg">
normalized
input
</ins></a>,<ins class="diff-chg">
replace
the
object
in
the
</ins><a class="tref" title="recusion_input_list"><ins class="diff-chg">
recusion
input
list
</ins></a><ins class="diff-chg">
with
a
new
object
containing
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
key
where
the
value
is
the
value
of
the
</ins><code><ins class="diff-chg">
@iri
</ins></code>,<ins class="diff-chg">
and
all
of
the
other
key-value
pairs
for
that
subject.
Set
the
</ins><dfn title="recursion_match_frame" id="dfn-recursion_match_frame"><ins class="diff-chg">
recursion
match
frame
</ins></dfn><ins class="diff-chg">
to
the
value
associated
with
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
's
key.
Replace
the
value
associated
with
the
key
by
recursively
calling
this
algorithm
using
</ins><a class="tref internalDFN" title="recursion_input_list" href="#dfn-recursion_input_list"><ins class="diff-chg">
recursion
input
list
</ins></a>,<a class="tref internalDFN" title="recursion_match_frame" href="#dfn-recursion_match_frame"><ins class="diff-chg">
recursion
match
frame
</ins></a><ins class="diff-chg">
as
input.
</ins></li><li><ins class="diff-chg">
If
the
key
is
not
in
the
item,
add
the
key
to
the
item
and
set
the
associated
value
to
an
empty
array
if
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
key's
value
is
an
array
or
</ins><code><ins class="diff-chg">
null
</ins></code><ins class="diff-chg">
otherwise.
</ins></li><li><ins class="diff-chg">
If
value
associated
with
the
item's
key
is
</ins><code><ins class="diff-chg">
null
</ins></code>,<ins class="diff-chg">
process
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
value
associated
with
the
key
in
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
is
an
array,
use
the
first
frame
from
the
array
as
the
</ins><dfn title="property_frame" id="dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></dfn>,<ins class="diff-chg">
otherwise
set
the
</ins><a class="tref internalDFN" title="property_frame" href="#dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></a><ins class="diff-chg">
to
an
empty
object.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="property_frame" href="#dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></a><ins class="diff-chg">
contains
an
</ins><code><ins class="diff-chg">
@omitDefault
</ins></code><ins class="diff-chg">
keyword,
set
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a><ins class="diff-chg">
to
its
value.
Note:
if
the
keyword
exists,
but
the
value
is
neither
</ins><code><ins class="diff-chg">
true
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
false
</ins></code>,<ins class="diff-chg">
set
the
associated
flag
to
</ins><code><ins class="diff-chg">
true
</ins></code>.</li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a><ins class="diff-chg">
is
set,
delete
the
key
in
the
item.
Otherwise,
if
the
</ins><code><ins class="diff-chg">
@default
</ins></code><ins class="diff-chg">
keyword
is
set
in
the
</ins><a class="tref internalDFN" title="property_frame" href="#dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></a><ins class="diff-chg">
set
the
item's
value
to
the
value
of
</ins><code><ins class="diff-chg">
@default
</ins></code>.</li></ol></li></ol></li></ol></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
is
</ins><code><ins class="diff-chg">
null
</ins></code><ins class="diff-chg">
set
it
to
the
item,
otherwise,
append
the
item
to
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Return
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.</li></ol><ins class="diff-chg">
The
final,
non-recursive
step
of
the
framing
algorithm
requires
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
be
compacted
according
to
the
</ins><a href="#compaction-algorithm"><ins class="diff-chg">
Compaction
Algorithm
</ins></a><ins class="diff-chg">
by
using
the
context
provided
in
the
</ins><a class="tref internalDFN" title="input_frame" href="#dfn-input_frame"><ins class="diff-chg">
input
frame
</ins></a>.<ins class="diff-chg">
The
resulting
value
is
the
final
output
of
the
compaction
algorithm
and
is
what
should
be
returned
to
the
application.
</ins></div></div><div id="normalization-1" class="section"><h3><span class="secno"><ins class="diff-chg">
6.11
</ins></span><ins class="diff-chg">
Normalization
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
Normalization
is
the
process
of
taking
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
and
performing
a
deterministic
transformation
on
that
input
that
results
in
all
aspects
of
the
graph
being
fully
expanded
and
named
in
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.<ins class="diff-chg">
The
normalized
output
is
generated
in
such
a
way
that
any
conforming
JSON-LD
processor
will
generate
identical
output
given
the
same
input.
The
problem
is
a
fairly
difficult
technical
problem
to
solve
because
it
requires
a
directed
graph
to
be
ordered
into
a
set
of
nodes
and
edges
in
a
deterministic
way.
This
is
easy
to
do
when
all
of
the
nodes
have
unique
names,
but
very
difficult
to
do
when
some
of
the
nodes
are
not
labeled.
</ins></p><p><ins class="diff-chg">
In
time,
there
may
be
more
than
one
normalization
algorithm
that
will
need
to
be
identified.
For
identification
purposes,
this
algorithm
is
named
</ins><abbr title="Universal Graph Normalization Algorithm 2011"><ins class="diff-chg">
UGNA2011
</ins></abbr>.</p><div id="normalization-algorithm-terms" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.1
</ins></span><ins class="diff-chg">
Normalization
Algorithm
Terms
</ins></h4><dl><dt><dfn title="label" id="dfn-label"><ins class="diff-chg">
label
</ins></dfn></dt><dd><ins class="diff-chg">
The
subject
IRI
associated
with
a
graph
node.
The
subject
IRI
is
expressed
using
a
key-value
pair
in
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
where
the
key
is
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
and
the
value
is
a
string
that
is
an
IRI
or
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
containing
the
key
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
and
a
value
that
is
a
string
that
is
an
IRI.
</ins></dd><dt><dfn title="list_of_expanded_nodes" id="dfn-list_of_expanded_nodes"><ins class="diff-chg">
list
of
expanded
nodes
</ins></dfn></dt><dd><ins class="diff-chg">
A
list
of
all
nodes
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
graph
containing
no
embedded
objects
and
having
all
keys
and
values
expanded
according
to
the
steps
in
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a>.</dd><dt><dfn title="alpha" id="dfn-alpha"><ins class="diff-chg">
alpha
</ins></dfn><ins class="diff-chg">
and
</ins><dfn title="beta" id="dfn-beta"><ins class="diff-chg">
beta
</ins></dfn><ins class="diff-chg">
values
</ins></dt><dd><ins class="diff-chg">
The
words
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
refer
to
the
first
and
second
nodes
or
values
being
examined
in
an
algorithm.
The
names
are
merely
used
to
refer
to
each
input
value
to
a
comparison
algorithm.
</ins></dd><dt><dfn title="renaming_counter" id="dfn-renaming_counter"><ins class="diff-chg">
renaming
counter
</ins></dfn></dt><dd><ins class="diff-chg">
A
counter
that
is
used
during
the
</ins><a href="#node-relabeling-algorithm"><ins class="diff-chg">
Node
Relabeling
Algorithm
</ins></a>.<ins class="diff-chg">
The
counter
typically
starts
at
one
(1)
and
counts
up
for
every
node
that
is
relabeled.
There
will
be
two
such
renaming
counters
in
an
implementation
of
the
normalization
algorithm.
The
first
is
the
</ins><a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></a><ins class="diff-chg">
and
the
second
is
the
</ins><a class="tref" title="deterministic_labeling_counter"><ins class="diff-chg">
deterministic
labeling
counter
</ins></a>.</dd><dt><dfn title="serialization_label" id="dfn-serialization_label"><ins class="diff-chg">
serialization
label
</ins></dfn></dt><dd><ins class="diff-chg">
An
identifier
that
is
created
to
aid
in
the
normalization
process
in
the
</ins><a href="#deep-comparison-algorithm"><ins class="diff-chg">
Deep
Comparison
Algorithm
</ins></a>.<ins class="diff-chg">
The
value
typically
takes
the
form
of
</ins><code><ins class="diff-chg">
s
</ins><NUMBER></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
c
</ins><NUMBER></code>.</dd></dl></div><div id="normalization-state" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.2
</ins></span><ins class="diff-chg">
Normalization
State
</ins></h4><p><ins class="diff-chg">
When
performing
the
steps
required
by
the
normalization
algorithm,
it
is
helpful
to
track
the
many
pieces
of
information
in
a
data
structure
called
the
</ins><dfn title="normalization_state" id="dfn-normalization_state"><ins class="diff-chg">
normalization
state
</ins></dfn>.<ins class="diff-chg">
Many
of
these
pieces
simply
provide
indexes
into
the
graph.
The
information
contained
in
the
</ins><a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state"><ins class="diff-chg">
normalization
state
</ins></a><ins class="diff-chg">
is
described
below.
</ins></p><dl><dt><dfn title="node_state" id="dfn-node_state"><ins class="diff-chg">
node
state
</ins></dfn></dt><dd><ins class="diff-chg">
Each
node
in
the
graph
will
be
assigned
a
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>.<ins class="diff-chg">
This
state
contains
the
information
necessary
to
deterministically
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
all
nodes
in
the
graph.
A
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
includes:
</ins><dl><dt><dfn title="node_reference" id="dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></dfn></dt><dd><ins class="diff-chg">
A
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
is
a
reference
to
a
node
in
the
graph.
For
a
given
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
its
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
refers
to
the
node
that
the
state
is
for.
When
a
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
is
created,
its
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
should
be
to
the
node
it
is
created
for.
</ins></dd><dt><dfn title="outgoing_list" id="dfn-outgoing_list"><ins class="diff-chg">
outgoing
list
</ins></dfn></dt><dd><ins class="diff-chg">
Lists
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
for
all
nodes
that
are
properties
of
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a>.<ins class="diff-chg">
This
list
should
be
initialized
by
iterating
over
every
object
associated
with
a
property
in
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
adding
its
label
if
it
is
another
node.
</ins></dd><dt><dfn title="incoming_list" id="dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></dfn></dt><dd><ins class="diff-chg">
Lists
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
for
all
nodes
in
the
graph
for
which
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
is
a
property.
This
list
is
initialized
to
an
empty
list.
</ins></dd><dt><dfn title="outgoing_serialization_map" id="dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></dfn></dt><dd><ins class="diff-chg">
Maps
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
to
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
s.
This
map
is
initialized
to
an
empty
map.
When
this
map
is
populated,
it
will
be
filled
with
keys
that
are
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
of
every
node
in
the
graph
with
a
label
that
begins
with
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
and
that
has
a
path,
via
properties,
that
starts
with
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a>.</dd><dt><dfn title="outgoing_serialization" id="dfn-outgoing_serialization"><ins class="diff-chg">
outgoing
serialization
</ins></dfn></dt><dd><ins class="diff-chg">
A
string
that
can
be
lexicographically
compared
to
the
</ins><a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization"><ins class="diff-chg">
outgoing
serialization
</ins></a><ins class="diff-chg">
s
of
other
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
s.
It
is
a
representation
of
the
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a><ins class="diff-chg">
and
other
related
information.
This
string
is
initialized
to
an
empty
string.
</ins></dd><dt><dfn title="incoming_serialization_map" id="dfn-incoming_serialization_map"><ins class="diff-chg">
incoming
serialization
map
</ins></dfn></dt><dd><ins class="diff-chg">
Maps
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
to
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
s.
This
map
is
initialized
to
an
empty
map.
When
this
map
is
populated,
it
will
be
filled
with
keys
that
are
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
of
every
node
in
the
graph
with
a
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
that
begins
with
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
and
that
has
a
path,
via
properties,
that
ends
with
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a>.</dd><dt><dfn title="incoming_serialization" id="dfn-incoming_serialization"><ins class="diff-chg">
incoming
serialization
</ins></dfn></dt><dd><ins class="diff-chg">
A
string
that
can
be
lexicographically
compared
to
the
</ins><a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization"><ins class="diff-chg">
outgoing
serialization
</ins></a><ins class="diff-chg">
s
of
other
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
s.
It
is
a
representation
of
the
</ins><a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map"><ins class="diff-chg">
incoming
serialization
map
</ins></a><ins class="diff-chg">
and
other
related
information.
This
string
is
initialized
to
an
empty
string.
</ins></dd></dl></dd><dt><dfn title="node_state_map" id="dfn-node_state_map"><ins class="diff-chg">
node
state
map
</ins></dfn></dt><dd><ins class="diff-chg">
A
mapping
from
a
node's
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
to
a
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>.<ins class="diff-chg">
It
is
initialized
to
an
empty
map.
</ins></dd><dt><dfn title="labeling_prefix" id="dfn-labeling_prefix"><ins class="diff-chg">
labeling
prefix
</ins></dfn></dt><dd><ins class="diff-chg">
The
labeling
prefix
is
a
string
that
is
used
as
the
beginning
of
a
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a>.<ins class="diff-chg">
It
should
be
initialized
to
a
random
base
string
that
starts
with
the
characters
</ins><code><ins class="diff-chg">
_:
</ins></code>,<ins class="diff-chg">
is
not
used
by
any
other
node's
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a>,<ins class="diff-chg">
and
does
not
start
with
the
characters
</ins><code><ins class="diff-chg">
_:c14n
</ins></code>.<ins class="diff-chg">
The
prefix
has
two
uses.
First
it
is
used
to
temporarily
name
nodes
during
the
normalization
algorithm
in
a
way
that
doesn't
collide
with
the
names
that
already
exist
as
well
as
the
names
that
will
be
generated
by
the
normalization
algorithm.
Second,
it
will
eventually
be
set
to
</ins><code><ins class="diff-chg">
_:c14n
</ins></code><ins class="diff-chg">
to
generate
the
final,
deterministic
labels
for
nodes
in
the
graph.
This
prefix
will
be
concatenated
with
the
</ins><a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></a><ins class="diff-chg">
to
produce
a
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a>.<ins class="diff-chg">
For
example,
</ins><code><ins class="diff-chg">
_:j8r3k
</ins></code><ins class="diff-chg">
is
a
proper
initial
value
for
the
</ins><a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix"><ins class="diff-chg">
labeling
prefix
</ins></a>.</dd><dt><dfn title="labeling_counter" id="dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></dfn></dt><dd><ins class="diff-chg">
A
counter
that
is
used
to
label
nodes.
It
is
appended
to
the
</ins><a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix"><ins class="diff-chg">
labeling
prefix
</ins></a><ins class="diff-chg">
to
create
a
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a>.<ins class="diff-chg">
It
is
initialized
to
</ins><code><ins class="diff-chg">
1
</ins></code>.</dd><dt><dfn title="map_of_flattened_nodes" id="dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></dfn></dt><dd><ins class="diff-chg">
A
map
containing
a
representation
of
all
nodes
in
the
graph
where
the
key
is
a
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
and
the
value
is
a
single
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
that
has
no
nested
sub-objects
and
has
had
all
properties
for
the
same
node
merged
into
a
single
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a>.</dd></dl></div><div id="normalization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.3
</ins></span><ins class="diff-chg">
Normalization
Algorithm
</ins></h4><p><ins class="diff-chg">
The
normalization
algorithm
expands
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a>,<ins class="diff-chg">
flattens
the
data
structure,
and
creates
an
initial
set
of
names
for
all
nodes
in
the
graph.
The
flattened
data
structure
is
then
processed
by
a
node
labeling
algorithm
in
order
to
get
a
fully
expanded
and
named
list
of
nodes
which
is
then
sorted.
The
result
is
a
deterministically
named
and
ordered
list
of
graph
nodes.
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Expand
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a><ins class="diff-chg">
and
store
the
result
as
the
</ins><strong><ins class="diff-chg">
expanded
input
</ins></strong>.</li><li><ins class="diff-chg">
Create
a
</ins><a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state"><ins class="diff-chg">
normalization
state
</ins></a>.</li><li><ins class="diff-chg">
Initialize
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a><ins class="diff-chg">
by
recursively
processing
every
</ins><dfn title="expanded_node" id="dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></dfn><ins class="diff-chg">
in
the
</ins><strong><ins class="diff-chg">
expanded
input
</ins></strong><ins class="diff-chg">
in
depth-first
order:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a><ins class="diff-chg">
is
an
unlabeled
node,
add
a
new
key-value
pair
to
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a><ins class="diff-chg">
where
the
key
is
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
and
the
value
is
the
concatenation
of
the
</ins><a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix"><ins class="diff-chg">
labeling
prefix
</ins></a><ins class="diff-chg">
and
the
string
value
of
the
</ins><a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></a>.<ins class="diff-chg">
Increment
the
</ins><a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></a>.</li><li><ins class="diff-chg">
Add
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
is
already
in
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a><ins class="diff-chg">
merge
all
properties
from
the
entry
in
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a><ins class="diff-chg">
into
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a>.</li><li><ins class="diff-chg">
Go
through
every
property
associated
with
an
array
in
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a><ins class="diff-chg">
and
remove
any
duplicate
IRI
entries
from
the
array.
If
the
resulting
array
only
has
one
IRI
entry,
change
it
from
an
array
to
an
object.
</ins></li><li><ins class="diff-chg">
Set
the
entry
for
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a>.</li></ol></li><li><ins class="diff-chg">
After
exiting
the
recursive
step,
replace
the
reference
to
the
</ins><a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node"><ins class="diff-chg">
expanded
node
</ins></a><ins class="diff-chg">
with
an
object
containing
a
single
key-value
pair
where
the
key
is
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
and
the
value
is
the
value
of
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
key
in
the
node.
</ins></li></ol></li><li><ins class="diff-chg">
For
every
entry
in
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a>,<ins class="diff-chg">
insert
a
key-value
pair
into
the
</ins><a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map"><ins class="diff-chg">
node
state
map
</ins></a><ins class="diff-chg">
where
the
key
is
the
key
from
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a><ins class="diff-chg">
and
the
value
is
a
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
where
its
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
refers
to
the
value
from
the
</ins><a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes"><ins class="diff-chg">
map
of
flattened
nodes
</ins></a>.</li><li><ins class="diff-chg">
Populate
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
for
each
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
by
iterating
over
every
node
in
the
graph
and
adding
its
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
associated
with
each
node
found
in
its
properties.
</ins></li><li><ins class="diff-chg">
For
every
entry
in
the
</ins><a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map"><ins class="diff-chg">
node
state
map
</ins></a><ins class="diff-chg">
that
has
a
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
that
begins
with
</ins><code><ins class="diff-chg">
_:c14n
</ins></code>,<ins class="diff-chg">
relabel
the
node
using
the
</ins><a href="#node-relabeling-algorithm"><ins class="diff-chg">
Node
Relabeling
Algorithm
</ins></a>.</li><li><ins class="diff-chg">
Label
all
of
the
nodes
that
contain
a
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
key
associated
with
a
value
starting
with
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#deterministic-labeling-algorithm"><ins class="diff-chg">
Deterministic
Labeling
Algorithm
</ins></a>.</li></ol></div><div id="node-relabeling-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.4
</ins></span><ins class="diff-chg">
Node
Relabeling
Algorithm
</ins></h4><p><ins class="diff-chg">
This
algorithm
renames
a
node
by
generating
a
unique
</ins><dfn title="new_label" id="dfn-new_label"><ins class="diff-chg">
new
label
</ins></dfn><ins class="diff-chg">
and
updating
all
references
to
that
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map"><ins class="diff-chg">
node
state
map
</ins></a>.<ins class="diff-chg">
The
</ins><dfn title="old_label" id="dfn-old_label"><ins class="diff-chg">
old
label
</ins></dfn><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state"><ins class="diff-chg">
normalization
state
</ins></a><ins class="diff-chg">
must
be
given
as
an
input
to
the
algorithm.
The
</ins><a class="tref internalDFN" title="old_label" href="#dfn-old_label"><ins class="diff-chg">
old
label
</ins></a><ins class="diff-chg">
is
the
current
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
of
the
node
that
is
to
be
relabeled.
</ins></p><p><ins class="diff-chg">
The
node
relabeling
algorithm
is
as
follows:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix"><ins class="diff-chg">
labeling
prefix
</ins></a><ins class="diff-chg">
is
</ins><code><ins class="diff-chg">
_:c14n
</ins></code><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="old_label" href="#dfn-old_label"><ins class="diff-chg">
old
label
</ins></a><ins class="diff-chg">
begins
with
</ins><code><ins class="diff-chg">
_:c14n
</ins></code><ins class="diff-chg">
then
return
as
the
node
has
already
been
renamed.
</ins></li><li><ins class="diff-chg">
Generate
the
</ins><dfn title="new_label" id="dfn-new_label-1"><ins class="diff-chg">
new
label
</ins></dfn><ins class="diff-chg">
by
concatenating
the
</ins><a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix"><ins class="diff-chg">
labeling
prefix
</ins></a><ins class="diff-chg">
with
the
string
value
of
the
</ins><a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></a>.<ins class="diff-chg">
Increment
the
</ins><a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></a>.</li><li><ins class="diff-chg">
For
the
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
associated
with
the
</ins><a class="tref internalDFN" title="old_label" href="#dfn-old_label"><ins class="diff-chg">
old
label
</ins></a>,<ins class="diff-chg">
update
every
node
in
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
by
changing
all
the
properties
that
reference
the
</ins><a class="tref internalDFN" title="old_label" href="#dfn-old_label"><ins class="diff-chg">
old
label
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="new_label" href="#dfn-new_label-1"><ins class="diff-chg">
new
label
</ins></a>.</li><li><ins class="diff-chg">
Change
the
</ins><a class="tref internalDFN" title="old_label" href="#dfn-old_label"><ins class="diff-chg">
old
label
</ins></a><ins class="diff-chg">
key
in
the
</ins><a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map"><ins class="diff-chg">
node
state
map
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="new_label" href="#dfn-new_label-1"><ins class="diff-chg">
new
label
</ins></a><ins class="diff-chg">
and
set
the
associated
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="new_label" href="#dfn-new_label-1"><ins class="diff-chg">
new
label
</ins></a>.</li></ol></div><div id="deterministic-labeling-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.5
</ins></span><ins class="diff-chg">
Deterministic
Labeling
Algorithm
</ins></h4><p><ins class="diff-chg">
The
deterministic
labeling
algorithm
takes
the
</ins><a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state"><ins class="diff-chg">
normalization
state
</ins></a><ins class="diff-chg">
and
produces
a
</ins><dfn title="list_of_finished_nodes" id="dfn-list_of_finished_nodes"><ins class="diff-chg">
list
of
finished
nodes
</ins></dfn><ins class="diff-chg">
that
is
sorted
and
contains
deterministically
named
and
expanded
nodes
from
the
graph.
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Set
the
</ins><a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix"><ins class="diff-chg">
labeling
prefix
</ins></a><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
_:c14n
</ins></code>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter"><ins class="diff-chg">
labeling
counter
</ins></a><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
1
</ins></code>,<ins class="diff-chg">
the
</ins><dfn title="list_of_finished_nodes" id="dfn-list_of_finished_nodes-1"><ins class="diff-chg">
list
of
finished
nodes
</ins></dfn><ins class="diff-chg">
to
an
empty
array,
and
create
an
empty
array,
the
</ins><dfn title="list_of_unfinished_nodes" id="dfn-list_of_unfinished_nodes"><ins class="diff-chg">
list
of
unfinished
nodes
</ins></dfn>.</li><li><ins class="diff-chg">
For
each
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map"><ins class="diff-chg">
node
state
map
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
node's
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
does
not
start
with
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
then
put
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1"><ins class="diff-chg">
list
of
finished
nodes
</ins></a>.</li><li><ins class="diff-chg">
If
the
node's
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
does
start
with
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
then
put
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes"><ins class="diff-chg">
list
of
unfinished
nodes
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Append
to
the
</ins><a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1"><ins class="diff-chg">
list
of
finished
nodes
</ins></a><ins class="diff-chg">
by
processing
the
remainder
of
the
</ins><a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes"><ins class="diff-chg">
list
of
unfinished
nodes
</ins></a><ins class="diff-chg">
until
it
is
empty:
</ins><ol class="algorithm"><li><ins class="diff-chg">
Sort
the
</ins><a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes"><ins class="diff-chg">
list
of
unfinished
nodes
</ins></a><ins class="diff-chg">
in
descending
order
according
to
the
</ins><a href="#deep-comparison-algorithm"><ins class="diff-chg">
Deep
Comparison
Algorithm
</ins></a><ins class="diff-chg">
to
determine
the
sort
order.
</ins></li><li><ins class="diff-chg">
Create
a
</ins><dfn title="list_of_labels" id="dfn-list_of_labels"><ins class="diff-chg">
list
of
labels
</ins></dfn><ins class="diff-chg">
and
initialize
it
to
an
empty
array.
</ins></li><li><ins class="diff-chg">
For
the
first
node
from
the
</ins><a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes"><ins class="diff-chg">
list
of
unfinished
nodes
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
Add
its
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="list_of_labels" href="#dfn-list_of_labels"><ins class="diff-chg">
list
of
labels
</ins></a>.</li><li><ins class="diff-chg">
For
each
key-value
pair
from
its
associated
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a>,<ins class="diff-chg">
add
the
key
to
a
list
and
then
sort
the
list
according
to
the
lexicographical
order
of
the
keys'
associated
values.
Append
the
list
to
the
</ins><a class="tref" title="list_of_nodes_to_label"><ins class="diff-chg">
list
of
nodes
to
label
</ins></a>.</li><li><ins class="diff-chg">
For
each
key-value
pair
from
its
associated
</ins><a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map"><ins class="diff-chg">
incoming
serialization
map
</ins></a>,<ins class="diff-chg">
add
the
key
to
a
list
and
then
sort
the
list
according
to
the
lexicographical
order
of
the
keys'
associated
values.
Append
the
list
to
the
</ins><a class="tref" title="list_of_nodes_to_label"><ins class="diff-chg">
list
of
nodes
to
label
</ins></a>.</li></ol></li><li><ins class="diff-chg">
For
each
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="list_of_labels" href="#dfn-list_of_labels"><ins class="diff-chg">
list
of
labels
</ins></a>,<ins class="diff-chg">
relabel
the
associated
node
according
to
the
</ins><a href="#node-relabeling-algorithm"><ins class="diff-chg">
Node
Relabeling
Algorithm
</ins></a>.<ins class="diff-chg">
If
any
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a><ins class="diff-chg">
contains
a
key
that
matches
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a>,<ins class="diff-chg">
clear
the
map
and
set
the
associated
</ins><a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization"><ins class="diff-chg">
outgoing
serialization
</ins></a><ins class="diff-chg">
to
an
empty
string.
If
any
</ins><a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map"><ins class="diff-chg">
incoming
serialization
map
</ins></a><ins class="diff-chg">
contains
a
key
that
matches
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a>,<ins class="diff-chg">
clear
the
map
and
set
the
associated
</ins><a class="tref internalDFN" title="incoming_serialization" href="#dfn-incoming_serialization"><ins class="diff-chg">
incoming
serialization
</ins></a><ins class="diff-chg">
to
an
empty
string.
</ins></li><li><ins class="diff-chg">
Remove
each
node
with
a
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
that
starts
with
</ins><code><ins class="diff-chg">
_:c14n
</ins></code><ins class="diff-chg">
from
the
</ins><a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes"><ins class="diff-chg">
list
of
unfinished
nodes
</ins></a><ins class="diff-chg">
and
add
it
to
the
</ins><a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1"><ins class="diff-chg">
list
of
finished
nodes
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Sort
the
</ins><a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1"><ins class="diff-chg">
list
of
finished
nodes
</ins></a><ins class="diff-chg">
in
descending
order
according
to
the
</ins><a href="#deep-comparison-algorithm"><ins class="diff-chg">
Deep
Comparison
Algorithm
</ins></a><ins class="diff-chg">
to
determine
the
sort
order.
</ins></li></ol></div><div id="shallow-comparison-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.6
</ins></span><ins class="diff-chg">
Shallow
Comparison
Algorithm
</ins></h4><p><ins class="diff-chg">
The
shallow
comparison
algorithm
takes
two
unlabeled
nodes,
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a>,<ins class="diff-chg">
as
input
and
determines
which
one
should
come
first
in
a
sorted
list.
The
following
algorithm
determines
the
steps
that
are
executed
in
order
to
determine
the
node
that
should
come
first
in
a
list:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Compare
the
total
number
of
node
properties.
The
node
with
fewer
properties
is
first.
</ins></li><li><ins class="diff-chg">
Lexicographically
sort
the
property
IRIs
for
each
node
and
compare
the
sorted
lists.
If
an
IRI
is
found
to
be
lexicographically
smaller,
the
node
containing
that
IRI
is
first.
</ins></li><li><ins class="diff-chg">
Compare
the
values
of
each
property
against
one
another:
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
node
associated
with
fewer
property
values
is
first.
</ins></li><li><ins class="diff-chg">
Create
an
</ins><dfn title="alpha_list" id="dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></dfn><ins class="diff-chg">
by
adding
all
values
associated
with
the
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
property
that
are
not
unlabeled
nodes.
</ins></li><li><ins class="diff-chg">
Create
a
</ins><dfn title="beta_list" id="dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></dfn><ins class="diff-chg">
by
adding
all
values
associated
with
the
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
property
that
is
not
an
unlabeled
node.
</ins></li><li><ins class="diff-chg">
Compare
the
length
of
</ins><a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta_list" href="#dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></a>.<ins class="diff-chg">
The
node
associated
with
the
list
containing
the
fewer
number
of
items
is
first.
</ins></li><li><ins class="diff-chg">
Sort
</ins><a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta_list" href="#dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#object-comparison-algorithm"><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></a>.<ins class="diff-chg">
For
each
offset
into
the
</ins><a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></a>,<ins class="diff-chg">
compare
the
item
at
the
offset
against
the
item
at
the
same
offset
in
the
</ins><a class="tref internalDFN" title="beta_list" href="#dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#object-comparison-algorithm"><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></a>.<ins class="diff-chg">
The
node
associated
with
the
lesser
item
is
first.
</ins></li></ol></li><li><ins class="diff-chg">
Process
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
s
associated
with
each
node
to
determine
order:
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
node
with
the
shortest
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
Sort
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
s
according
to
incoming
property
and
then
incoming
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a>.</li><li><ins class="diff-chg">
The
node
associated
with
the
fewest
number
of
incoming
nodes
is
first.
</ins></li><li><ins class="diff-chg">
For
each
offset
into
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
s,
compare
the
associated
properties
and
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s:
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
node
associated
with
a
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
that
does
not
begin
with
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
If
the
nodes'
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
do
not
begin
with
</ins><code><ins class="diff-chg">
_:
</ins></code>,<ins class="diff-chg">
then
the
node
associated
with
the
lexicographically
lesser
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
The
node
associated
with
the
lexicographically
lesser
associated
property
is
first.
</ins></li><li><ins class="diff-chg">
The
node
with
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
that
does
not
begin
with
</ins><code><ins class="diff-chg">
_:c14n
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
The
node
with
the
lexicographically
lesser
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
is
first.
</ins></li></ol></li></ol></li><li><ins class="diff-chg">
Otherwise,
the
nodes
are
equivalent.
</ins></li></ol></div><div id="object-comparison-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.7
</ins></span><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></h4><p><ins class="diff-chg">
The
object
comparison
algorithm
is
designed
to
compare
two
graph
node
property
values,
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a>,<ins class="diff-chg">
against
the
other.
The
algorithm
is
useful
when
sorting
two
lists
of
graph
node
properties.
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
one
of
the
values
is
a
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a><ins class="diff-chg">
and
the
other
is
not,
the
value
that
is
a
string
is
first.
</ins></li><li><ins class="diff-chg">
If
both
values
are
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a><ins class="diff-chg">
s,
the
lexicographically
lesser
string
is
first.
</ins></li><li><ins class="diff-chg">
If
one
of
the
values
is
a
literal
and
the
other
is
not,
the
value
that
is
a
literal
is
first.
</ins></li><li><ins class="diff-chg">
If
both
values
are
literals:
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
The
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@datatype
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
The
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
is
first.
</ins></li></ol></li><li><ins class="diff-chg">
If
both
values
are
expanded
IRIs,
the
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
Otherwise,
the
two
values
are
equivalent.
</ins></li></ol></div><div id="deep-comparison-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.8
</ins></span><ins class="diff-chg">
Deep
Comparison
Algorithm
</ins></h4><p><ins class="diff-chg">
The
deep
comparison
algorithm
is
used
to
compare
the
difference
between
two
nodes,
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a>.<ins class="diff-chg">
A
deep
comparison
takes
the
incoming
and
outgoing
node
edges
in
a
graph
into
account
if
the
number
of
properties
and
value
of
those
properties
are
identical.
The
algorithm
is
helpful
when
sorting
a
list
of
nodes
and
will
return
whichever
node
should
be
placed
first
in
a
list
if
the
two
nodes
are
not
truly
equivalent.
</ins></p><p><ins class="diff-chg">
When
performing
the
steps
required
by
the
deep
comparison
algorithm,
it
is
helpful
to
track
state
information
about
mappings.
The
information
contained
in
a
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a><ins class="diff-chg">
is
described
below.
</ins></p><dl class="algorithm"><dt><dfn title="mapping_state" id="dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></dfn></dt><dd><dl><dt><dfn title="mapping_counter" id="dfn-mapping_counter"><ins class="diff-chg">
mapping
counter
</ins></dfn></dt><dd><ins class="diff-chg">
Keeps
track
of
the
number
of
nodes
that
have
been
mapped
to
</ins><a class="tref" title="serialization_labels"><ins class="diff-chg">
serialization
labels
</ins></a>.<ins class="diff-chg">
It
is
initialized
to
</ins><code><ins class="diff-chg">
1
</ins></code>.</dd><dt><dfn title="processed_labels_map" id="dfn-processed_labels_map"><ins class="diff-chg">
processed
labels
map
</ins></dfn></dt><dd><ins class="diff-chg">
Keeps
track
of
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
of
nodes
that
have
already
been
assigned
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
s.
It
is
initialized
to
an
empty
map.
</ins></dd><dt><dfn title="serialized_labels_map" id="dfn-serialized_labels_map"><ins class="diff-chg">
serialized
labels
map
</ins></dfn></dt><dd><ins class="diff-chg">
Maps
a
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
to
its
associated
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a>.<ins class="diff-chg">
It
is
initialized
to
an
empty
map.
</ins></dd><dt><dfn title="adjacent_info_map" id="dfn-adjacent_info_map"><ins class="diff-chg">
adjacent
info
map
</ins></dfn></dt><dd><ins class="diff-chg">
Maps
a
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
to
the
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
associated
with
it,
the
list
of
sorted
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
s
for
adjacent
nodes,
and
the
map
of
adjacent
node
</ins><a class="tref" title="serialiation_label"><ins class="diff-chg">
serialiation
label
</ins></a><ins class="diff-chg">
s
to
their
associated
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s.
It
is
initialized
to
an
empty
map.
</ins></dd><dt><dfn title="key_stack" id="dfn-key_stack"><ins class="diff-chg">
key
stack
</ins></dfn></dt><dd><ins class="diff-chg">
A
stack
where
each
element
contains
an
array
of
adjacent
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
s
and
an
index
into
that
array.
It
is
initialized
to
a
stack
containing
a
single
element
where
its
array
contains
a
single
string
element
</ins><code><ins class="diff-chg">
s1
</ins></code><ins class="diff-chg">
and
its
index
is
set
to
</ins><code><ins class="diff-chg">
0
</ins></code>.</dd><dt><dfn title="serialized_keys" id="dfn-serialized_keys"><ins class="diff-chg">
serialized
keys
</ins></dfn></dt><dd><ins class="diff-chg">
Keeps
track
of
which
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
s
have
already
been
written
at
least
once
to
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a>.<ins class="diff-chg">
It
is
initialized
to
an
empty
map.
</ins></dd><dt><dfn title="serialization_string" id="dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></dfn></dt><dd><ins class="diff-chg">
A
string
that
is
incrementally
updated
as
a
serialization
is
built.
It
is
initialized
to
an
empty
string.
</ins></dd></dl></dd></dl><p><ins class="diff-chg">
The
deep
comparison
algorithm
is
as
follows:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Perform
a
comparison
between
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#shallow-comparison-algorithm"><ins class="diff-chg">
Shallow
Comparison
Algorithm
</ins></a>.<ins class="diff-chg">
If
the
result
does
not
show
that
the
two
nodes
are
equivalent,
return
the
result.
</ins></li><li><ins class="diff-chg">
Compare
incoming
and
outgoing
edges
for
each
node,
updating
their
associated
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a><ins class="diff-chg">
as
each
node
is
processed:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a><ins class="diff-chg">
for
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
is
empty,
generate
the
serialization
according
to
the
</ins><a href="#node-serialization-algorithm"><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></a>.<ins class="diff-chg">
Provide
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
a
new
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a>,<code><ins class="diff-chg">
outgoing
direction
</ins></code><ins class="diff-chg">
to
the
algorithm
as
inputs.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a><ins class="diff-chg">
for
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
is
empty,
generate
the
serialization
according
to
the
</ins><a href="#node-serialization-algorithm"><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></a>.<ins class="diff-chg">
Provide
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
a
new
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a>,<ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
outgoing
direction
</ins></code><ins class="diff-chg">
to
the
algorithm
as
inputs.
</ins></li><li><ins class="diff-chg">
If
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization"><ins class="diff-chg">
outgoing
serialization
</ins></a><ins class="diff-chg">
is
lexicographically
less
than
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
's,
then
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
is
first.
If
it
is
greater,
then
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map"><ins class="diff-chg">
incoming
serialization
map
</ins></a><ins class="diff-chg">
for
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
is
empty,
generate
the
serialization
according
to
the
</ins><a href="#node-serialization-algorithm"><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></a>.<ins class="diff-chg">
Provide
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
a
new
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a><ins class="diff-chg">
with
its
</ins><a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map"><ins class="diff-chg">
serialized
labels
map
</ins></a><ins class="diff-chg">
set
to
a
copy
of
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a>,<ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
incoming
direction
</ins></code><ins class="diff-chg">
to
the
algorithm
as
inputs.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map"><ins class="diff-chg">
incoming
serialization
map
</ins></a><ins class="diff-chg">
for
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
is
empty,
generate
the
serialization
according
to
the
</ins><a href="#node-serialization-algorithm"><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></a>.<ins class="diff-chg">
Provide
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
a
new
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a><ins class="diff-chg">
with
its
</ins><a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map"><ins class="diff-chg">
serialized
labels
map
</ins></a><ins class="diff-chg">
set
to
a
copy
of
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a>,<ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
incoming
direction
</ins></code><ins class="diff-chg">
to
the
algorithm
as
inputs.
</ins></li><li><ins class="diff-chg">
If
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="incoming_serialization" href="#dfn-incoming_serialization"><ins class="diff-chg">
incoming
serialization
</ins></a><ins class="diff-chg">
is
lexicographically
less
than
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
's,
then
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
is
first.
If
it
is
greater,
then
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
is
first.
</ins></li></ol></li></ol></div><div id="node-serialization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.9
</ins></span><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></h4><p><ins class="diff-chg">
The
node
serialization
algorithm
takes
a
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
a
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a>,<ins class="diff-chg">
and
a
</ins><dfn title="direction" id="dfn-direction"><ins class="diff-chg">
direction
</ins></dfn><ins class="diff-chg">
(either
</ins><code><ins class="diff-chg">
outgoing
direction
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
incoming
direction
</ins></code><ins class="diff-chg">
)
as
inputs
and
generates
a
deterministic
serialization
for
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a>.</p><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
exists
in
the
</ins><a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map"><ins class="diff-chg">
processed
labels
map
</ins></a>,<ins class="diff-chg">
terminate
the
algorithm
as
the
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
has
already
been
created.
</ins></li><li><ins class="diff-chg">
Set
the
value
associated
with
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map"><ins class="diff-chg">
processed
labels
map
</ins></a><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
true
</ins></code>.</li><li><ins class="diff-chg">
Generate
the
next
</ins><dfn title="serialization_label" id="dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></dfn><ins class="diff-chg">
for
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#serialization-label-generation-algorithm"><ins class="diff-chg">
Serialization
Label
Generation
Algorithm
</ins></a>.</li><li><ins class="diff-chg">
Create
an
empty
map
called
the
</ins><dfn title="adjacent_serialized_labels_map" id="dfn-adjacent_serialized_labels_map"><ins class="diff-chg">
adjacent
serialized
labels
map
</ins></dfn><ins class="diff-chg">
that
will
store
mappings
from
</ins><a class="tref" title="serialized_label"><ins class="diff-chg">
serialized
label
</ins></a><ins class="diff-chg">
s
to
adjacent
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s.
</ins></li><li><ins class="diff-chg">
Create
an
empty
array
called
the
</ins><dfn title="adjacent_unserialized_labels_list" id="dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></dfn><ins class="diff-chg">
that
will
store
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
s
of
adjacent
nodes
that
haven't
been
assigned
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
s
yet.
</ins></li><li><ins class="diff-chg">
For
every
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
in
a
list,
where
the
list
the
</ins><a class="tref internalDFN" title="outgoing_list" href="#dfn-outgoing_list"><ins class="diff-chg">
outgoing
list
</ins></a><ins class="diff-chg">
if
the
</ins><a class="tref internalDFN" title="direction" href="#dfn-direction"><ins class="diff-chg">
direction
</ins></a><ins class="diff-chg">
is
</ins><code><ins class="diff-chg">
outgoing
direction
</ins></code><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a><ins class="diff-chg">
otherwise,
if
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
starts
with
</ins><code><ins class="diff-chg">
_:
</ins></code>,<ins class="diff-chg">
it
is
the
</ins><dfn title="target_node_label" id="dfn-target_node_label"><ins class="diff-chg">
target
node
label
</ins></dfn>:<ol class="algorithm"><li><ins class="diff-chg">
Look
up
the
</ins><a class="tref internalDFN" title="target_node_label" href="#dfn-target_node_label"><ins class="diff-chg">
target
node
label
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map"><ins class="diff-chg">
processed
labels
map
</ins></a><ins class="diff-chg">
and
if
a
mapping
exists,
update
the
</ins><a class="tref internalDFN" title="adjacent_serialized_labels_map" href="#dfn-adjacent_serialized_labels_map"><ins class="diff-chg">
adjacent
serialized
labels
map
</ins></a><ins class="diff-chg">
where
the
key
is
the
value
in
the
</ins><a class="tref" title="serialization_map"><ins class="diff-chg">
serialization
map
</ins></a><ins class="diff-chg">
and
the
value
is
the
</ins><a class="tref internalDFN" title="target_node_label" href="#dfn-target_node_label"><ins class="diff-chg">
target
node
label
</ins></a>.</li><li><ins class="diff-chg">
Otherwise,
add
the
</ins><a class="tref internalDFN" title="target_node_label" href="#dfn-target_node_label"><ins class="diff-chg">
target
node
label
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Set
the
</ins><dfn title="maximum_serialization_combinations" id="dfn-maximum_serialization_combinations"><ins class="diff-chg">
maximum
serialization
combinations
</ins></dfn><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
1
</ins></code><ins class="diff-chg">
or
the
length
of
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a>,<ins class="diff-chg">
whichever
is
greater.
</ins></li><li><ins class="diff-chg">
While
the
</ins><a class="tref internalDFN" title="maximum_serialization_combinations" href="#dfn-maximum_serialization_combinations"><ins class="diff-chg">
maximum
serialization
combinations
</ins></a><ins class="diff-chg">
is
greater
than
</ins><code><ins class="diff-chg">
0
</ins></code>,<ins class="diff-chg">
perform
the
</ins><a href="#combinatorial-serialization-algorithm"><ins class="diff-chg">
Combinatorial
Serialization
Algorithm
</ins></a><ins class="diff-chg">
passing
the
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a><ins class="diff-chg">
for
the
first
iteration
and
a
copy
of
it
for
each
subsequent
iteration,
the
generated
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="direction" href="#dfn-direction"><ins class="diff-chg">
direction
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="adjacent_serialized_labels_map" href="#dfn-adjacent_serialized_labels_map"><ins class="diff-chg">
adjacent
serialized
labels
map
</ins></a>,<ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a>.<ins class="diff-chg">
Decrement
the
</ins><a class="tref internalDFN" title="maximum_serialization_combinations" href="#dfn-maximum_serialization_combinations"><ins class="diff-chg">
maximum
serialization
combinations
</ins></a><ins class="diff-chg">
by
</ins><code><ins class="diff-chg">
1
</ins></code><ins class="diff-chg">
for
each
iteration.
</ins></li></ol></div><div id="serialization-label-generation-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.10
</ins></span><ins class="diff-chg">
Serialization
Label
Generation
Algorithm
</ins></h4><p><ins class="diff-chg">
The
algorithm
generates
a
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
given
a
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
and
a
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a><ins class="diff-chg">
and
returns
the
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a>.</p><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
is
already
in
the
</ins><a class="tref" title="serialization_labels_map"><ins class="diff-chg">
serialization
labels
map
</ins></a>,<ins class="diff-chg">
return
its
associated
value.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
starts
with
the
string
</ins><code><ins class="diff-chg">
_:c14n
</ins></code>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
is
the
letter
</ins><code><ins class="diff-chg">
c
</ins></code><ins class="diff-chg">
followed
by
the
number
that
follows
</ins><code><ins class="diff-chg">
_:c14n
</ins></code><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a>.</li><li><ins class="diff-chg">
Otherwise,
the
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
is
the
letter
</ins><code><ins class="diff-chg">
s
</ins></code><ins class="diff-chg">
followed
by
the
string
value
of
</ins><a class="tref" title="mapping_count"><ins class="diff-chg">
mapping
count
</ins></a>.<ins class="diff-chg">
Increment
the
</ins><a class="tref" title="mapping_count"><ins class="diff-chg">
mapping
count
</ins></a><ins class="diff-chg">
by
</ins><code><ins class="diff-chg">
1
</ins></code>.</li><li><ins class="diff-chg">
Create
a
new
key-value
pair
in
the
</ins><a class="tref" title="serialization_labels_map"><ins class="diff-chg">
serialization
labels
map
</ins></a><ins class="diff-chg">
where
the
key
is
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
and
the
value
is
the
generated
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a>.</li></ol></div><div id="combinatorial-serialization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.11
</ins></span><ins class="diff-chg">
Combinatorial
Serialization
Algorithm
</ins></h4><p><ins class="diff-chg">
The
combinatorial
serialization
algorithm
takes
a
</ins><a class="tref internalDFN" title="node_state" href="#dfn-node_state"><ins class="diff-chg">
node
state
</ins></a>,<ins class="diff-chg">
a
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a>,<ins class="diff-chg">
a
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a>,<ins class="diff-chg">
a
</ins><a class="tref internalDFN" title="direction" href="#dfn-direction"><ins class="diff-chg">
direction
</ins></a>,<ins class="diff-chg">
a
</ins><a class="tref internalDFN" title="adjacent_serialized_labels_map" href="#dfn-adjacent_serialized_labels_map"><ins class="diff-chg">
adjacent
serialized
labels
map
</ins></a>,<ins class="diff-chg">
and
a
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a><ins class="diff-chg">
as
inputs
and
generates
the
lexicographically
least
serialization
of
nodes
relating
to
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a>.</p><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a><ins class="diff-chg">
is
not
empty:
</ins><ol class="algorithm"><li><ins class="diff-chg">
Copy
the
</ins><a class="tref internalDFN" title="adjacent_serialized_labels_map" href="#dfn-adjacent_serialized_labels_map"><ins class="diff-chg">
adjacent
serialized
labels
map
</ins></a><ins class="diff-chg">
to
the
</ins><dfn title="adjacent_serialized_labels_map_copy" id="dfn-adjacent_serialized_labels_map_copy"><ins class="diff-chg">
adjacent
serialized
labels
map
copy
</ins></dfn>.</li><li><ins class="diff-chg">
Remove
the
first
</ins><a class="tref" title="unserialized_label"><ins class="diff-chg">
unserialized
label
</ins></a><ins class="diff-chg">
from
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a><ins class="diff-chg">
and
create
a
new
</ins><dfn title="new_serialization_label" id="dfn-new_serialization_label"><ins class="diff-chg">
new
serialization
label
</ins></dfn><ins class="diff-chg">
according
to
the
</ins><a href="#serialization-label-generation-algorithm"><ins class="diff-chg">
Serialization
Label
Generation
Algorithm
</ins></a>.</li><li><ins class="diff-chg">
Create
a
new
key-value
mapping
in
the
</ins><a class="tref internalDFN" title="adjacent_serialized_labels_map_copy" href="#dfn-adjacent_serialized_labels_map_copy"><ins class="diff-chg">
adjacent
serialized
labels
map
copy
</ins></a><ins class="diff-chg">
where
the
key
is
the
</ins><a class="tref internalDFN" title="new_serialization_label" href="#dfn-new_serialization_label"><ins class="diff-chg">
new
serialization
label
</ins></a><ins class="diff-chg">
and
the
value
is
the
</ins><a class="tref" title="unserialized_label"><ins class="diff-chg">
unserialized
label
</ins></a>.</li><li><ins class="diff-chg">
Set
the
</ins><dfn title="maximum_serialization_rotations" id="dfn-maximum_serialization_rotations"><ins class="diff-chg">
maximum
serialization
rotations
</ins></dfn><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
1
</ins></code><ins class="diff-chg">
or
the
length
of
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a>,<ins class="diff-chg">
whichever
is
greater.
</ins></li><li><ins class="diff-chg">
While
the
</ins><a class="tref internalDFN" title="maximum_serialization_rotations" href="#dfn-maximum_serialization_rotations"><ins class="diff-chg">
maximum
serialization
rotations
</ins></a><ins class="diff-chg">
is
greater
than
</ins><code><ins class="diff-chg">
0
</ins></code>:<ol class="algorithm"><li><ins class="diff-chg">
Recursively
perform
the
</ins><a href="#combinatorial-serialization-algorithm"><ins class="diff-chg">
Combinatorial
Serialization
Algorithm
</ins></a><ins class="diff-chg">
passing
the
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a><ins class="diff-chg">
for
the
first
iteration
of
the
loop,
and
a
copy
of
it
for
each
subsequent
iteration.
</ins></li><li><ins class="diff-chg">
Rotate
the
elements
in
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a><ins class="diff-chg">
by
shifting
each
of
them
once
to
the
right,
moving
the
element
at
the
end
of
the
list
to
the
beginning
of
the
list.
</ins></li><li><ins class="diff-chg">
Decrement
the
</ins><a class="tref internalDFN" title="maximum_serialization_rotations" href="#dfn-maximum_serialization_rotations"><ins class="diff-chg">
maximum
serialization
rotations
</ins></a><ins class="diff-chg">
by
</ins><code><ins class="diff-chg">
1
</ins></code><ins class="diff-chg">
for
each
iteration.
</ins></li></ol></li></ol></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="adjacent_unserialized_labels_list" href="#dfn-adjacent_unserialized_labels_list"><ins class="diff-chg">
adjacent
unserialized
labels
list
</ins></a><ins class="diff-chg">
is
empty:
</ins><ol class="algorithm"><li><ins class="diff-chg">
Create
a
</ins><dfn title="list_of_keys" id="dfn-list_of_keys"><ins class="diff-chg">
list
of
keys
</ins></dfn><ins class="diff-chg">
from
the
keys
in
the
</ins><a class="tref internalDFN" title="adjacent_serialized_labels_map" href="#dfn-adjacent_serialized_labels_map"><ins class="diff-chg">
adjacent
serialized
labels
map
</ins></a><ins class="diff-chg">
and
sort
it
lexicographically.
</ins></li><li><ins class="diff-chg">
Add
a
key-value
pair
to
the
</ins><a class="tref internalDFN" title="adjacent_info_map" href="#dfn-adjacent_info_map"><ins class="diff-chg">
adjacent
info
map
</ins></a><ins class="diff-chg">
where
the
key
is
the
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a><ins class="diff-chg">
and
the
value
is
an
object
containing
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a><ins class="diff-chg">
's
label,
the
</ins><a class="tref internalDFN" title="list_of_keys" href="#dfn-list_of_keys"><ins class="diff-chg">
list
of
keys
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="adjacent_serialized_labels_map" href="#dfn-adjacent_serialized_labels_map"><ins class="diff-chg">
adjacent
serialized
labels
map
</ins></a>.</li><li><ins class="diff-chg">
Update
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#mapping-serialization-algorithm"><ins class="diff-chg">
Mapping
Serialization
Algorithm
</ins></a>.</li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="direction" href="#dfn-direction"><ins class="diff-chg">
direction
</ins></a><ins class="diff-chg">
is
</ins><code><ins class="diff-chg">
outgoing
direction
</ins></code><ins class="diff-chg">
then
</ins><dfn title="directed_serialization" id="dfn-directed_serialization"><ins class="diff-chg">
directed
serialization
</ins></dfn><ins class="diff-chg">
refers
to
the
</ins><a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization"><ins class="diff-chg">
outgoing
serialization
</ins></a><ins class="diff-chg">
and
the
</ins><dfn title="directed_serialization_map" id="dfn-directed_serialization_map"><ins class="diff-chg">
directed
serialization
map
</ins></dfn><ins class="diff-chg">
refers
to
the
</ins><a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map"><ins class="diff-chg">
outgoing
serialization
map
</ins></a>,<ins class="diff-chg">
otherwise
it
refers
to
the
</ins><a class="tref internalDFN" title="incoming_serialization" href="#dfn-incoming_serialization"><ins class="diff-chg">
incoming
serialization
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="directed_serialization_map" href="#dfn-directed_serialization_map"><ins class="diff-chg">
directed
serialization
map
</ins></a><ins class="diff-chg">
refers
to
the
</ins><a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map"><ins class="diff-chg">
incoming
serialization
map
</ins></a>.<ins class="diff-chg">
Compare
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="directed_serialization" href="#dfn-directed_serialization"><ins class="diff-chg">
directed
serialization
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#mapping-serialization-algorithm"><ins class="diff-chg">
Serialization
Comparison
Algorithm
</ins></a>.<ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
is
less
than
or
equal
to
the
</ins><a class="tref internalDFN" title="directed_serialization" href="#dfn-directed_serialization"><ins class="diff-chg">
directed
serialization
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
For
each
value
in
the
</ins><a class="tref internalDFN" title="list_of_keys" href="#dfn-list_of_keys"><ins class="diff-chg">
list
of
keys
</ins></a>,<ins class="diff-chg">
run
the
</ins><a href="#node-serialization-algorithm"><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></a>.</li><li><ins class="diff-chg">
Update
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#mapping-serialization-algorithm"><ins class="diff-chg">
Mapping
Serialization
Algorithm
</ins></a>.</li><li><ins class="diff-chg">
Compare
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="directed_serialization" href="#dfn-directed_serialization"><ins class="diff-chg">
directed
serialization
</ins></a><ins class="diff-chg">
again
and
if
it
is
less
than
or
equal
and
the
length
of
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
is
greater
than
or
equal
to
the
length
of
the
</ins><a class="tref internalDFN" title="directed_serialization" href="#dfn-directed_serialization"><ins class="diff-chg">
directed
serialization
</ins></a>,<ins class="diff-chg">
then
set
the
</ins><a class="tref internalDFN" title="directed_serialization" href="#dfn-directed_serialization"><ins class="diff-chg">
directed
serialization
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
and
set
the
</ins><a class="tref internalDFN" title="directed_serialization_map" href="#dfn-directed_serialization_map"><ins class="diff-chg">
directed
serialization
map
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map"><ins class="diff-chg">
serialized
labels
map
</ins></a>.</li></ol></li></ol></li></ol></div><div id="serialization-comparison-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.12
</ins></span><ins class="diff-chg">
Serialization
Comparison
Algorithm
</ins></h4><p><ins class="diff-chg">
The
serialization
comparison
algorithm
takes
two
serializations,
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
and
returns
either
which
of
the
two
is
less
than
the
other
or
that
they
are
equal.
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Whichever
serialization
is
an
empty
string
is
greater.
If
they
are
both
empty
strings,
they
are
equal.
</ins></li><li><ins class="diff-chg">
Return
the
result
of
a
lexicographical
comparison
of
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
up
to
the
number
of
characters
in
the
shortest
of
the
two
serializations.
</ins></li></ol></div><div id="mapping-serialization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.13
</ins></span><ins class="diff-chg">
Mapping
Serialization
Algorithm
</ins></h4><p><ins class="diff-chg">
The
mapping
serialization
algorithm
incrementally
updates
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
in
a
</ins><a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state"><ins class="diff-chg">
mapping
state
</ins></a>.</p><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="key_stack" href="#dfn-key_stack"><ins class="diff-chg">
key
stack
</ins></a><ins class="diff-chg">
is
not
empty:
</ins><ol class="algorithm"><li><ins class="diff-chg">
Pop
the
</ins><dfn title="serialization_key_info" id="dfn-serialization_key_info"><ins class="diff-chg">
serialization
key
info
</ins></dfn><ins class="diff-chg">
off
of
the
</ins><a class="tref internalDFN" title="key_stack" href="#dfn-key_stack"><ins class="diff-chg">
key
stack
</ins></a>.</li><li><ins class="diff-chg">
For
each
</ins><dfn title="serialization_key" id="dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></dfn><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="serialization_key_info" href="#dfn-serialization_key_info"><ins class="diff-chg">
serialization
key
info
</ins></a><ins class="diff-chg">
array,
starting
at
the
</ins><dfn title="serialization_key_index" id="dfn-serialization_key_index"><ins class="diff-chg">
serialization
key
index
</ins></dfn><ins class="diff-chg">
from
the
</ins><a class="tref internalDFN" title="serialization_key_info" href="#dfn-serialization_key_info"><ins class="diff-chg">
serialization
key
info
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></a><ins class="diff-chg">
is
not
in
the
</ins><a class="tref internalDFN" title="adjacent_info_map" href="#dfn-adjacent_info_map"><ins class="diff-chg">
adjacent
info
map
</ins></a>,<ins class="diff-chg">
push
the
</ins><a class="tref internalDFN" title="serialization_key_info" href="#dfn-serialization_key_info"><ins class="diff-chg">
serialization
key
info
</ins></a><ins class="diff-chg">
onto
the
</ins><a class="tref internalDFN" title="key_stack" href="#dfn-key_stack"><ins class="diff-chg">
key
stack
</ins></a><ins class="diff-chg">
and
exit
from
this
loop.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></a><ins class="diff-chg">
is
a
key
in
</ins><a class="tref internalDFN" title="serialized_keys" href="#dfn-serialized_keys"><ins class="diff-chg">
serialized
keys
</ins></a>,<ins class="diff-chg">
a
cycle
has
been
detected.
Append
the
concatenation
of
the
</ins><code><ins class="diff-chg">
_
</ins></code><ins class="diff-chg">
character
and
the
</ins><a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a>.</li><li><ins class="diff-chg">
Otherwise,
serialize
all
outgoing
and
incoming
edges
in
the
related
node
by
performing
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
Mark
the
</ins><a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></a><ins class="diff-chg">
as
having
been
processed
by
adding
a
new
key-value
pair
to
</ins><a class="tref internalDFN" title="serialized_keys" href="#dfn-serialized_keys"><ins class="diff-chg">
serialized
keys
</ins></a><ins class="diff-chg">
where
the
key
is
the
</ins><a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></a><ins class="diff-chg">
and
the
value
is
</ins><code><ins class="diff-chg">
true
</ins></code>.</li><li><ins class="diff-chg">
Set
the
</ins><dfn title="serialization_fragment" id="dfn-serialization_fragment"><ins class="diff-chg">
serialization
fragment
</ins></dfn><ins class="diff-chg">
to
the
value
of
the
</ins><a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></a>.</li><li><ins class="diff-chg">
Set
the
</ins><a class="tref" title="adjacent_info"><ins class="diff-chg">
adjacent
info
</ins></a><ins class="diff-chg">
to
the
value
of
the
</ins><a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key"><ins class="diff-chg">
serialization
key
</ins></a><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="adjacent_info_map" href="#dfn-adjacent_info_map"><ins class="diff-chg">
adjacent
info
map
</ins></a>.</li><li><ins class="diff-chg">
Set
the
</ins><a class="tref" title="adjacent_node_label"><ins class="diff-chg">
adjacent
node
label
</ins></a><ins class="diff-chg">
to
the
node
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
from
the
</ins><a class="tref" title="adjacent_info"><ins class="diff-chg">
adjacent
info
</ins></a>.</li><li><ins class="diff-chg">
If
a
mapping
for
the
</ins><a class="tref" title="adjacent_node_label"><ins class="diff-chg">
adjacent
node
label
</ins></a><ins class="diff-chg">
exists
in
the
</ins><a class="tref" title="map_of_all_labels"><ins class="diff-chg">
map
of
all
labels
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
Append
the
result
of
the
</ins><a href=""><ins class="diff-chg">
Label
Serialization
Algorithm
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="serialization_fragment" href="#dfn-serialization_fragment"><ins class="diff-chg">
serialization
fragment
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Append
all
of
the
keys
in
the
</ins><a class="tref" title="adjacent_info"><ins class="diff-chg">
adjacent
info
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="serialization_fragment" href="#dfn-serialization_fragment"><ins class="diff-chg">
serialization
fragment
</ins></a>.</li><li><ins class="diff-chg">
Append
the
</ins><a class="tref internalDFN" title="serialization_fragment" href="#dfn-serialization_fragment"><ins class="diff-chg">
serialization
fragment
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a>.</li><li><ins class="diff-chg">
Push
a
new
key
info
object
containing
the
keys
from
the
</ins><a class="tref" title="adjacent_info"><ins class="diff-chg">
adjacent
info
</ins></a><ins class="diff-chg">
and
an
index
of
</ins><code><ins class="diff-chg">
0
</ins></code><ins class="diff-chg">
onto
the
</ins><a class="tref internalDFN" title="key_stack" href="#dfn-key_stack"><ins class="diff-chg">
key
stack
</ins></a>.</li><li><ins class="diff-chg">
Recursively
update
the
</ins><a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string"><ins class="diff-chg">
serialization
string
</ins></a><ins class="diff-chg">
according
to
the
</ins><a href="#mapping-serialization-algorithm"><ins class="diff-chg">
Mapping
Serialization
Algorithm
</ins></a>.</li></ol></li></ol></li></ol></li></ol></div><div id="label-serialization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.11.14
</ins></span><ins class="diff-chg">
Label
Serialization
Algorithm
</ins></h4><p><ins class="diff-chg">
The
label
serialization
algorithm
serializes
information
about
a
node
that
has
been
assigned
a
particular
</ins><a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1"><ins class="diff-chg">
serialization
label
</ins></a>.</p><ol class="algorithm"><li><ins class="diff-chg">
Initialize
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a><ins class="diff-chg">
to
an
empty
string.
</ins></li><li><ins class="diff-chg">
Append
the
</ins><code><ins class="diff-chg">
[
</ins></code><ins class="diff-chg">
character
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
Append
all
properties
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a><ins class="diff-chg">
by
processing
each
key-value
pair
in
the
</ins><a class="tref internalDFN" title="node_reference" href="#dfn-node_reference"><ins class="diff-chg">
node
reference
</ins></a>,<ins class="diff-chg">
excluding
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property.
The
keys
should
be
processed
in
lexicographical
order
and
their
associated
values
should
be
processed
in
the
order
produced
by
the
</ins><a href="#object-comparison-algorithm"><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
Build
a
string
using
the
pattern
</ins><code><</code><strong><ins class="diff-chg">
KEY
</ins></strong><code><ins class="diff-chg">
>
</ins></code><ins class="diff-chg">
where
</ins><strong><ins class="diff-chg">
KEY
</ins></strong><ins class="diff-chg">
is
the
current
key.
Append
string
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
The
value
may
be
a
single
object
or
an
array
of
objects.
Process
all
of
the
objects
that
are
associated
with
the
key,
building
an
</ins><dfn title="object_string" id="dfn-object_string"><ins class="diff-chg">
object
string
</ins></dfn><ins class="diff-chg">
for
each
item:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
object
contains
an
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
key
with
a
value
that
starts
with
</ins><code><ins class="diff-chg">
_:
</ins></code>,<ins class="diff-chg">
set
the
</ins><a class="tref internalDFN" title="object_string" href="#dfn-object_string"><ins class="diff-chg">
object
string
</ins></a><ins class="diff-chg">
to
the
value
</ins><code><ins class="diff-chg">
_:
</ins></code>.<ins class="diff-chg">
If
the
value
does
not
start
with
</ins><code><ins class="diff-chg">
_:
</ins></code>,<ins class="diff-chg">
build
the
</ins><a class="tref internalDFN" title="object_string" href="#dfn-object_string"><ins class="diff-chg">
object
string
</ins></a><ins class="diff-chg">
using
the
pattern
</ins><code><</code><strong><ins class="diff-chg">
IRI
</ins></strong><code><ins class="diff-chg">
>
</ins></code><ins class="diff-chg">
where
</ins><strong><ins class="diff-chg">
IRI
</ins></strong><ins class="diff-chg">
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
key.
</ins></li><li><ins class="diff-chg">
If
the
object
contains
a
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
key
and
a
</ins><code><ins class="diff-chg">
@datatype
</ins></code><ins class="diff-chg">
key,
build
the
</ins><a class="tref internalDFN" title="object_string" href="#dfn-object_string"><ins class="diff-chg">
object
string
</ins></a><ins class="diff-chg">
using
the
pattern
</ins><code><ins class="diff-chg">
"
</ins></code><strong><ins class="diff-chg">
LITERAL
</ins></strong><code><ins class="diff-chg">
"^^
</ins><</code><strong><ins class="diff-chg">
DATATYPE
</ins></strong><code><ins class="diff-chg">
>
</ins></code><ins class="diff-chg">
where
</ins><strong><ins class="diff-chg">
LITERAL
</ins></strong><ins class="diff-chg">
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
key
and
</ins><strong><ins class="diff-chg">
DATATYPE
</ins></strong><ins class="diff-chg">
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@datatype
</ins></code><ins class="diff-chg">
key.
</ins></li><li><ins class="diff-chg">
If
the
object
contains
a
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
key
and
a
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
key,
build
the
</ins><a class="tref internalDFN" title="object_string" href="#dfn-object_string"><ins class="diff-chg">
object
string
</ins></a><ins class="diff-chg">
using
the
pattern
</ins><code><ins class="diff-chg">
"
</ins></code><strong><ins class="diff-chg">
LITERAL
</ins></strong><code><ins class="diff-chg">
"@
</ins></code><strong><ins class="diff-chg">
LANGUAGE
</ins></strong><ins class="diff-chg">
where
</ins><strong><ins class="diff-chg">
LITERAL
</ins></strong><ins class="diff-chg">
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
key
and
</ins><strong><ins class="diff-chg">
LANGUAGE
</ins></strong><ins class="diff-chg">
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
key.
</ins></li><li><ins class="diff-chg">
Otherwise,
the
value
is
a
string.
Build
the
</ins><a class="tref internalDFN" title="object_string" href="#dfn-object_string"><ins class="diff-chg">
object
string
</ins></a><ins class="diff-chg">
using
the
pattern
</ins><code><ins class="diff-chg">
"
</ins></code><strong><ins class="diff-chg">
LITERAL
</ins></strong><code><ins class="diff-chg">
"
</ins></code><ins class="diff-chg">
where
</ins><strong><ins class="diff-chg">
LITERAL
</ins></strong><ins class="diff-chg">
is
the
value
associated
with
the
current
key.
</ins></li><li><ins class="diff-chg">
If
this
is
the
second
iteration
of
the
loop,
append
a
</ins><code><ins class="diff-chg">
|
</ins></code><ins class="diff-chg">
separator
character
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
Append
the
</ins><a class="tref internalDFN" title="object_string" href="#dfn-object_string"><ins class="diff-chg">
object
string
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li></ol></li></ol></li><li><ins class="diff-chg">
Append
the
</ins><code><ins class="diff-chg">
]
</ins></code><ins class="diff-chg">
character
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
Append
the
</ins><code><ins class="diff-chg">
[
</ins></code><ins class="diff-chg">
character
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
Append
all
incoming
references
for
the
current
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a><ins class="diff-chg">
by
processing
all
of
the
items
associated
with
the
</ins><a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list"><ins class="diff-chg">
incoming
list
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
Build
a
</ins><dfn title="reference_string" id="dfn-reference_string"><ins class="diff-chg">
reference
string
</ins></dfn><ins class="diff-chg">
using
the
pattern
</ins><code><</code><strong><ins class="diff-chg">
PROPERTY
</ins></strong><code><ins class="diff-chg">
>
</ins></code><code><</code><strong><ins class="diff-chg">
REFERER
</ins></strong><code><ins class="diff-chg">
>
</ins></code><ins class="diff-chg">
where
</ins><strong><ins class="diff-chg">
PROPERTY
</ins></strong><ins class="diff-chg">
is
the
property
associated
with
the
incoming
reference
and
</ins><strong><ins class="diff-chg">
REFERER
</ins></strong><ins class="diff-chg">
is
either
the
subject
of
the
node
referring
to
the
</ins><a class="tref internalDFN" title="label" href="#dfn-label"><ins class="diff-chg">
label
</ins></a><ins class="diff-chg">
in
the
incoming
reference
or
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
if
</ins><strong><ins class="diff-chg">
REFERER
</ins></strong><ins class="diff-chg">
begins
with
</ins><code><ins class="diff-chg">
_:
</ins></code>.</li><li><ins class="diff-chg">
If
this
is
the
second
iteration
of
the
loop,
append
a
</ins><code><ins class="diff-chg">
|
</ins></code><ins class="diff-chg">
separator
character
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
Append
the
</ins><a class="tref internalDFN" title="reference_string" href="#dfn-reference_string"><ins class="diff-chg">
reference
string
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Append
the
</ins><code><ins class="diff-chg">
]
</ins></code><ins class="diff-chg">
character
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
Append
all
</ins><a class="tref" title="adjacent_node_labels"><ins class="diff-chg">
adjacent
node
labels
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a><ins class="diff-chg">
by
concatenating
the
string
value
for
all
of
them,
one
after
the
other,
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li><li><ins class="diff-chg">
Push
the
</ins><a class="tref" title="adjacent_node_labels"><ins class="diff-chg">
adjacent
node
labels
</ins></a><ins class="diff-chg">
onto
the
</ins><a class="tref internalDFN" title="key_stack" href="#dfn-key_stack"><ins class="diff-chg">
key
stack
</ins></a><ins class="diff-chg">
and
append
the
result
of
the
</ins><a href="#mapping-serialization-algorithm"><ins class="diff-chg">
Mapping
Serialization
Algorithm
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref" title="label_serialization"><ins class="diff-chg">
label
serialization
</ins></a>.</li></ol></div></div><div id="data-round-tripping" class="section"><h3><span class="secno"><ins class="diff-chg">
6.12
</ins></span><ins class="diff-chg">
Data
Round
Tripping
</ins></h3><p><ins class="diff-chg">
When
normalizing
</ins><strong><ins class="diff-chg">
xsd:double
</ins></strong><ins class="diff-chg">
values,
implementers
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
ensure
that
the
normalized
value
is
a
string.
In
order
to
generate
the
string
from
a
</ins><strong><ins class="diff-chg">
double
</ins></strong><ins class="diff-chg">
value,
output
equivalent
to
the
</ins><code><ins class="diff-chg">
printf("%1.6e",
value)
</ins></code><ins class="diff-chg">
function
in
C
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
used
where
</ins><strong><ins class="diff-chg">
"%1.6e"
</ins></strong><ins class="diff-chg">
is
the
string
formatter
and
</ins><strong><ins class="diff-chg">
value
</ins></strong><ins class="diff-chg">
is
the
value
to
be
converted.
</ins></p><p><ins class="diff-chg">
To
convert
the
a
double
value
in
JavaScript,
implementers
can
use
the
following
snippet
of
code:
</ins></p><pre class="example"><ins class="diff-chg">
// the variable 'value' below is the JavaScript native double value that is to be converted
(value).toExponential(6).replace(/(e(?:\+|-))([0-9])$/,
'$10$2')
</ins></pre><p class="note"><ins class="diff-chg">
When
data
needs
to
be
normalized,
JSON-LD
authors
should
not
use
values
that
are
going
to
undergo
automatic
conversion.
This
is
due
to
the
lossy
nature
of
</ins><strong><ins class="diff-chg">
xsd:double
</ins></strong><ins class="diff-chg">
values.
</ins></p><p class="note"><ins class="diff-chg">
Some
JSON
serializers,
such
as
PHP's
native
implementation,
backslash-escapes
the
forward
slash
character.
For
example,
the
value
</ins><code><ins class="diff-chg">
http://example.com/
</ins></code><ins class="diff-chg">
would
be
serialized
as
</ins><code><ins class="diff-chg">
http:\/\/example.com\/
</ins></code><ins class="diff-chg">
in
some
versions
of
PHP.
This
is
problematic
when
generating
a
byte
stream
for
processes
such
as
normalization.
There
is
no
need
to
backslash-escape
forward-slashes
in
JSON-LD.
To
aid
interoperability
between
JSON-LD
processors,
a
JSON-LD
serializer
</ins><em class="rfc2119" title="must not"><ins class="diff-chg">
must
not
</ins></em><ins class="diff-chg">
backslash-escape
forward
slashes.
</ins></p><p class="issue"><ins class="diff-chg">
Round-tripping
data
can
be
problematic
if
we
mix
and
match
@coerce
rules
with
JSON-native
datatypes,
like
integers.
Consider
the
following
code
example:
</ins></p><pre class="example"><ins class="diff-chg">
var myObj = { "@context" : {
                "number" : "http://example.com/vocab#number",
                "@coerce": {
                   "xsd:nonNegativeInteger": "number"
                }
              },
              "number" : 42 };
// Map the language-native object to JSON-LD
var jsonldText = jsonld.normalize(myObj);
// Convert the normalized object back to a JavaScript object
var
myObj2
=
jsonld.parse(jsonldText);
</ins></pre><p class="issue"><ins class="diff-chg">
At
this
point,
myObj2
and
myObj
will
have
different
values
for
the
"number"
value.
myObj
will
be
the
number
42,
while
myObj2
will
be
the
string
"42".
This
type
of
data
round-tripping
error
can
bite
developers.
We
are
currently
wondering
if
having
a
"coerce
validation"
phase
in
the
parsing/normalization
phases
would
be
a
good
idea.
It
would
prevent
data
round-tripping
issues
like
the
one
mentioned
above.
</ins></p></div><div id="rdf-conversion" class="section"><h3><span class="secno"><ins class="diff-chg">
6.13
</ins></span><ins class="diff-chg">
RDF
Conversion
</ins></h3><p><ins class="diff-chg">
A
JSON-LD
document
</ins><em class="rfc2119" title="may"><ins class="diff-chg">
may
</ins></em><ins class="diff-chg">
be
converted
to
any
other
RDF-compatible
document
format
using
the
algorithm
specified
in
this
section.
</ins></p><p><ins class="diff-chg">
The
JSON-LD
Processing
Model
describes
processing
rules
for
extracting
RDF
from
a
JSON-LD
document.
Note
that
many
uses
of
JSON-LD
may
not
require
generation
of
RDF.
</ins></p><p><ins class="diff-chg">
The
processing
algorithm
described
in
this
section
is
provided
in
order
to
demonstrate
how
one
might
implement
a
JSON-LD
to
RDF
processor.
Conformant
implementations
are
only
required
to
produce
the
same
type
and
number
of
triples
during
the
output
process
and
are
not
required
to
implement
the
algorithm
exactly
as
described.
</ins></p><p class="issue"><ins class="diff-chg">
The
RDF
Conversion
Algorithm
is
a
work
in
progress.
</ins></p><div class="informative section" id="overview"><h4><span class="secno"><ins class="diff-chg">
6.13.1
</ins></span><ins class="diff-chg">
Overview
</ins></h4><p><em><ins class="diff-chg">
This
section
is
non-normative.
</ins></em></p><p><ins class="diff-chg">
JSON-LD
is
intended
to
have
an
easy
to
parse
grammar
that
closely
models
existing
practice
in
using
JSON
for
describing
object
representations.
This
allows
the
use
of
existing
libraries
for
parsing
JSON
in
a
document-oriented
fashion,
or
can
allow
for
stream-based
parsing
similar
to
SAX.
</ins></p><p><ins class="diff-chg">
As
with
other
grammars
used
for
describing
</ins><a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data"><ins class="diff-chg">
Linked
Data
</ins></a>,<ins class="diff-chg">
a
key
concept
is
that
of
a
</ins><em><ins class="diff-chg">
resource
</ins></em>.<ins class="diff-chg">
Resources
may
be
of
three
basic
types:
</ins><em><ins class="diff-chg">
IRI
</ins></em><ins class="diff-chg">
s,
for
describing
externally
named
entities,
</ins><em><ins class="diff-chg">
BNodes
</ins></em>,<ins class="diff-chg">
resources
for
which
an
external
name
does
not
exist,
or
is
not
known,
and
Literals,
which
describe
terminal
entities
such
as
strings,
dates
and
other
representations
having
a
lexical
representation
possibly
including
an
explicit
language
or
datatype.
</ins></p><p><ins class="diff-chg">
Data
described
with
JSON-LD
may
be
considered
to
be
the
representation
of
a
graph
made
up
of
</ins><a class="tref internalDFN" title="subject" href="#dfn-subject-1"><ins class="diff-chg">
subject
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a><ins class="diff-chg">
resources
related
via
a
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-chg">
property
</ins></a><ins class="diff-chg">
resource.
However,
specific
implementations
may
choose
to
operate
on
the
document
as
a
normal
JSON
description
of
objects
having
attributes.
</ins></p></div><div id="rdf-conversion-algorithm-terms" class="section"><h4><span class="secno"><ins class="diff-chg">
6.13.2
</ins></span><ins class="diff-chg">
RDF
Conversion
Algorithm
Terms
</ins></h4><dl><dt><dfn title="default_graph" id="dfn-default_graph"><ins class="diff-chg">
default
graph
</ins></dfn></dt><dd><ins class="diff-chg">
the
destination
graph
for
all
triples
generated
by
JSON-LD
markup.
</ins></dd></dl></div><div id="rdf-conversion-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
6.13.3
</ins></span><ins class="diff-chg">
RDF
Conversion
Algorithm
</ins></h4><p><ins class="diff-chg">
The
algorithm
below
is
designed
for
in-memory
implementations
with
random
access
to
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
elements.
</ins></p><p><ins class="diff-chg">
A
conforming
JSON-LD
processor
implementing
RDF
conversion
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
implement
a
processing
algorithm
that
results
in
the
same
</ins><a class="tref internalDFN" title="default_graph" href="#dfn-default_graph"><ins class="diff-chg">
default
graph
</ins></a><ins class="diff-chg">
that
the
following
algorithm
generates:
</ins></p><ol class="algorithm"><li id="processing-step-default-context"><ins class="diff-chg">
Create
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
with
with
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
set
to
the
</ins><a class="tref internalDFN" title="initial_context" href="#dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
initialized
to
NULL.
</ins></li><li id="processing-step-associative"><ins class="diff-chg">
If
a
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
is
detected,
perform
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
has
a
</ins><code><ins class="diff-chg">
@context
</ins></code><ins class="diff-chg">
key,
process
the
local
context
as
described
in
</ins><a href="#context"><ins class="diff-chg">
Context
</ins></a>.</li><li><ins class="diff-chg">
Create
a
new
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
by
mapping
the
keys
from
the
current
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
using
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
to
new
keys
using
the
associated
value
from
the
current
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a>.<ins class="diff-chg">
Repeat
the
mapping
until
no
entry
is
found
within
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
for
the
key.
Use
the
new
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
in
subsequent
steps.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
has
an
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
key,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
by
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
associated
value.
Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a>.<ins class="diff-chg">
Return
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
the
calling
location.
</ins><p class="issue"><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
really
just
behaves
the
same
as
</ins><code><ins class="diff-chg">
@subject
</ins></code>,<ins class="diff-chg">
consider
consolidating
them.
</ins></p></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
has
a
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
key,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
a
literal
value
as
follows:
</ins><ol class="algorithm"><li><ins class="diff-chg">
as
a
</ins><a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal"><ins class="diff-chg">
typed
literal
</ins></a><ins class="diff-chg">
if
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
contains
a
</ins><code><ins class="diff-chg">
@datatype
</ins></code><ins class="diff-chg">
key
after
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
specified
</ins><code><ins class="diff-chg">
@datatype
</ins></code>.</li><li><ins class="diff-chg">
otherwise,
as
a
</ins><a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal"><ins class="diff-chg">
plain
literal
</ins></a>.<ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
contains
a
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
key,
use
it's
value
to
set
the
language
of
the
plain
literal.
</ins></li><li><ins class="diff-chg">
Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a>.<ins class="diff-chg">
Return
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
the
calling
location.
</ins></li></ol></li><li id="processing-step-subject"><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
has
a
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
key:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
value
is
a
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a>,<ins class="diff-chg">
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
the
result
of
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a>.<ins class="diff-chg">
Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a>.<ins class="diff-chg">
Set
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a>.</li><li><ins class="diff-chg">
Create
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
using
copies
of
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>,<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
process
the
value
starting
at
</ins><a href="#processing-step-associative"><ins class="diff-chg">
Step
2
</ins></a>,<ins class="diff-chg">
set
the
</ins><a class="tref" title="active__subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
to
the
result
and
proceed
using
the
previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>.</li></ol></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
does
not
have
a
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
key,
set
the
</ins><a class="tref" title="active__object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
newly
generated
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier"><ins class="diff-chg">
blank
node
identifier
</ins></dfn>.<ins class="diff-chg">
Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a>.<ins class="diff-chg">
Set
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref" title="active__object"><ins class="diff-chg">
active
object
</ins></a>.</li><li><ins class="diff-chg">
For
each
key
in
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins></a><ins class="diff-chg">
that
has
not
already
been
processed,
perform
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
key
is
</ins><code><ins class="diff-chg">
@type
</ins></code>,<ins class="diff-chg">
set
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
rdf:type
</ins></code>.</li><li><ins class="diff-chg">
Otherwise,
set
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
to
the
result
of
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
key.
</ins></li><li><ins class="diff-chg">
Create
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
copies
of
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>,<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
process
the
value
starting
at
</ins><a href="#processing-step-associative"><ins class="diff-chg">
Step
2
</ins></a><ins class="diff-chg">
and
proceed
using
the
previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Return
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
the
calling
location.
</ins></li></ol></li><li><ins class="diff-chg">
If
a
regular
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
is
detected,
process
each
value
in
the
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a><ins class="diff-chg">
by
doing
the
following
returning
the
result
of
processing
the
last
value
in
the
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
Create
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
using
copies
of
the
</ins><a class="tref" title="active__context"><ins class="diff-chg">
active
context
</ins></a>,<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
process
the
value
starting
at
</ins><a href="#processing-step-associative"><ins class="diff-chg">
Step
2
</ins></a><ins class="diff-chg">
then
proceed
using
the
previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>.</li></ol></li><li><ins class="diff-chg">
If
a
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-chg">
string
</ins></a><ins class="diff-chg">
is
detected:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
the
target
of
a
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
coercion,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
by
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
string.
</ins></li><li><ins class="diff-chg">
Otherwise,
if
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
the
target
of
coercion,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
by
creating
a
</ins><a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal"><ins class="diff-chg">
typed
literal
</ins></a><ins class="diff-chg">
using
the
string
and
the
coercion
key
as
the
datatype
IRI.
</ins></li><li><ins class="diff-chg">
Otherwise,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
a
</ins><a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal"><ins class="diff-chg">
plain
literal
</ins></a><ins class="diff-chg">
value
created
from
the
string.
</ins></li></ol><ins class="diff-chg">
Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a>.</li><li><ins class="diff-chg">
If
a
</ins><a class="tref internalDFN" title="number" href="#dfn-number"><ins class="diff-chg">
number
</ins></a><ins class="diff-chg">
is
detected,
generate
a
</ins><a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal"><ins class="diff-chg">
typed
literal
</ins></a><ins class="diff-chg">
using
a
string
representation
of
the
value
with
datatype
set
to
either
</ins><code><ins class="diff-chg">
xsd:integer
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
xsd:double
</ins></code>,<ins class="diff-chg">
depending
on
if
the
value
contains
a
fractional
and/or
an
exponential
component.
Generate
a
triple
using
the
</ins><a class="tref" title="active__subject"><ins class="diff-chg">
active
subject
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
the
generated
typed
literal.
</ins></li><li><ins class="diff-chg">
Otherwise,
if
</ins><strong><ins class="diff-chg">
true
</ins></strong><ins class="diff-chg">
or
</ins><strong><ins class="diff-chg">
false
</ins></strong><ins class="diff-chg">
is
detected,
generate
a
triple
using
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
a
</ins><a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal"><ins class="diff-chg">
typed
literal
</ins></a><ins class="diff-chg">
value
created
from
the
string
representation
of
the
value
with
datatype
set
to
</ins><code><ins class="diff-chg">
xsd:boolean
</ins></code>.</li></ol></div></div></div><div class="appendix section" id="experimental-concepts">
<h2>
<span class="secno">
A.
</span>
<ins class="diff-new">Experimental
Concepts
</ins></h2><p class="issue"><ins class="diff-new">
There
are
a
few
advanced
concepts
where
it
is
not
clear
whether
or
not
the
JSON-LD
specification
is
going
to
support
the
complexity
necessary
to
support
each
concept.
The
entire
section
on
Advanced
Concepts
should
be
considered
as
discussion
points;
it
is
merely
a
list
of
possibilities
where
all
of
the
benefits
and
drawbacks
have
not
been
explored.
</ins></p><div id="disjoint-graphs" class="section"><h3><span class="secno"><ins class="diff-new">
A.1
</ins></span><ins class="diff-new">
Disjoint
Graphs
</ins></h3><p><ins class="diff-new">
When
serializing
an
RDF
graph
that
contains
two
or
more
sections
of
the
graph
which
are
entirely
disjoint,
one
must
use
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-new">
array
</ins></a><ins class="diff-new">
to
express
the
graph
as
two
graphs.
This
may
not
be
acceptable
to
some
authors,
who
would
rather
express
the
information
as
one
graph.
Since,
by
definition,
disjoint
graphs
require
there
to
be
two
top-level
objects,
JSON-LD
utilizes
a
mechanism
that
allows
disjoint
graphs
to
be
expressed
using
a
single
graph.
</ins></p><p><ins class="diff-new">
Assume
the
following
RDF
graph:
</ins></p><pre class="example"><ins class="diff-new">
&lt;http://example.org/people#john&gt;
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
      &lt;http://xmlns.com/foaf/0.1/Person&gt; .
&lt;http://example.org/people#jane&gt;
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
&lt;http://xmlns.com/foaf/0.1/Person&gt;
.
</ins></pre><p><ins class="diff-new">
Since
the
two
subjects
are
entirely
disjoint
with
one
another,
it
is
impossible
to
express
the
RDF
graph
above
using
a
single
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-new">
JSON
object
</ins></a>.</p><p><ins class="diff-new">
In
JSON-LD,
one
can
use
the
subject
to
express
disjoint
graphs
as
a
single
graph:
</ins></p><pre class="example"><ins class="diff-new">
{
  "@context": {
    "Person": "http://xmlns.com/foaf/0.1/Person"
  },
  "@subject":
  [
    {
      "@subject": "http://example.org/people#john",
      "@type": "Person"
    },
    {
      "@subject": "http://example.org/people#jane",
      "@type": "Person"
    }
  ]
}
</ins></pre><p><ins class="diff-new">
A
disjoint
graph
could
also
be
expressed
like
so:
</ins></p><pre class="example"><ins class="diff-new">
[
  {
    "@subject": "http://example.org/people#john",
    "@type": "http://xmlns.com/foaf/0.1/Person"
  },
  {
    "@subject": "http://example.org/people#jane",
    "@type": "http://xmlns.com/foaf/0.1/Person"
  }
]
</ins></pre><p class="note"><ins class="diff-new">
Warning:
Using
this
serialisation
format
it
is
impossible
to
include
</ins><code><ins class="diff-new">
@context
</ins></code><ins class="diff-new">
given
that
the
document's
data
structure
is
an
array
and
not
an
object.
</ins></p></div><div id="lists" class="section"><h3><span class="secno"><ins class="diff-new">
A.2
</ins></span><ins class="diff-new">
Lists
</ins></h3><p><ins class="diff-new">
Because
graphs
do
not
describe
ordering
for
links
between
nodes,
in
contrast
to
plain
JSON,
multi-valued
properties
in
JSON-LD
do
not
provide
an
ordering
of
the
listed
objects.
For
example,
consider
the
following
simple
document:
</ins></p>  <pre class="example"><ins class="diff-new">
{
...
  "@subject": "http://example.org/people#joebob",
  "nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}
</ins></pre><p><ins class="diff-new">
This
results
in
three
triples
being
generated,
each
relating
the
subject
to
an
individual
object,
with
no
inherent
order.
</ins></p><p><ins class="diff-new">
To
preserve
the
order
of
the
objects,
RDF-based
languages,
such
as
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-TURTLE"><ins class="diff-new">
TURTLE
</ins></a></cite><ins class="diff-new">
]
use
the
concept
of
an
</ins><code><ins class="diff-new">
rdf:List
</ins></code><ins class="diff-new">
(as
described
in
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDF-SCHEMA"><ins class="diff-new">
RDF-SCHEMA
</ins></a></cite><ins class="diff-new">
]).
This
uses
a
sequence
of
unlabeled
nodes
with
properties
describing
a
value,
a
null-terminated
next
property.
Without
specific
syntactical
support,
this
could
be
represented
in
JSON-LD
as
follows:
</ins></p>  <pre class="example"><ins class="diff-new">
{
...
  "@subject": "http://example.org/people#joebob",
  "nick": <span class="diff">{</span>,
</ins>    <span class="diff">"@first": "joe"</span>,    <span class="diff">"@rest": {</span>      <span class="diff">"@first": "bob"</span>,      <span class="diff">"@rest": {</span>        <span class="diff">"@first": "jaybee"</span>,        <span class="diff">"@rest": "@nil"</span>        <span class="diff">}</span>      <span class="diff">}</span>    <span class="diff">}</span>  <span class="diff">}</span>,<ins class="diff-new">
...
}
</ins></pre><p><ins class="diff-new">
As
this
notation
is
rather
unwieldy
and
the
notion
of
ordered
collections
is
rather
important
in
data
modeling,
it
is
useful
to
have
specific
language
support.
In
JSON-LD,
a
list
may
be
represented
using
the
</ins><code><ins class="diff-new">
@list
</ins></code><ins class="diff-new">
keyword
as
follows:
</ins></p>  <pre class="example"><ins class="diff-new">
{
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">{"@list": ["joe", "bob", "jaybee"]}</span>,
...
}
</ins></pre><p><ins class="diff-new">
This
describes
the
use
of
this
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-new">
array
</ins></a><ins class="diff-new">
as
being
ordered,
and
order
is
maintained
through
normalization
and
RDF
conversion.
If
every
use
of
a
given
multi-valued
property
is
a
list,
this
may
be
abbreviated
by
adding
an
</ins><code><ins class="diff-new">
@coerce
</ins></code><ins class="diff-new">
term:
</ins></p>  <pre class="example"><ins class="diff-new">
{
</ins>  <span class="diff">"@context": {</span><ins class="diff-new">
    ...
</ins>    <span class="diff">"@coerce": {</span>      <span class="diff">"@list": ["foaf:nick"]</span>    <span class="diff">}</span>  <span class="diff">}</span>,<ins class="diff-new">
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}
</ins></pre><p class="issue"><ins class="diff-new">
There
is
an
ongoing
discussion
about
this
issue.
One
of
the
</ins><a href="https://github.com/json-ld/json-ld.org/issues/12"><ins class="diff-new">
proposed
solutions
</ins></a><ins class="diff-new">
is
allowing
to
change
the
default
behaviour
so
that
arrays
are
considered
as
ordered
lists
by
default.
</ins></p><div id="expansion-2" class="section"><h4 id="list-expansion"><span class="secno"><ins class="diff-new">
A.2.1
</ins></span><ins class="diff-new">
Expansion
</ins></h4><p class="issue"><ins class="diff-new">
TBD.
</ins></p></div><div id="normalization-2" class="section"><h4 id="list-normalization"><span class="secno"><ins class="diff-new">
A.2.2
</ins></span><ins class="diff-new">
Normalization
</ins></h4><p class="issue"><ins class="diff-new">
TBD.
</ins></p></div><div id="rdf-conversion-1" class="section"><h4 id="list-rdf"><span class="secno"><ins class="diff-new">
A.2.3
</ins></span><ins class="diff-new">
RDF
Conversion
</ins></h4><p><ins class="diff-new">
To
support
RDF
Conversion
of
lists,
</ins><a href="#rdf-conversion-algorithm"><ins class="diff-new">
RDF
Conversion
Algorithm
</ins></a><ins class="diff-new">
is
updated
as
follows:
</ins></p><ol class="algorithm update"><li><span class="list-number"><ins class="diff-new">
2.4a.
</ins></span><ins class="diff-new">
If
the
</ins><a class="tref internalDFN" title="JSON_object" href="#dfn-json_object"><ins class="diff-new">
JSON
object
</ins></a><ins class="diff-new">
has
a
</ins><code><ins class="diff-new">
@list
</ins></code><ins class="diff-new">
key
and
the
value
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-new">
array
</ins></a><ins class="diff-new">
process
the
value
as
a
list
starting
at
</ins><a href="#processing-step-list"><ins class="diff-new">
Step
3a
</ins></a>.</li><li><span class="list-number"><ins class="diff-new">
2.7.3.
</ins></span><ins class="diff-new">
Create
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-new">
processor
state
</ins></a><ins class="diff-new">
copies
of
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a>,<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a><ins class="diff-new">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>.<ol class="algorithm"><li><ins class="diff-new">
If
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
is
the
target
of
a
</ins><code><ins class="diff-new">
@list
</ins></code><ins class="diff-new">
coercion,
and
the
value
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-new">
array
</ins></a>,<ins class="diff-new">
process
the
value
as
a
list
starting
at
</ins><a href="#processing-step-list"><ins class="diff-new">
Step
3a
</ins></a>.</li><li><ins class="diff-new">
Otherwise,
process
the
value
starting
at
</ins><a href="#processing-step-associative"><ins class="diff-new">
Step
2
</ins></a>.</li><li><ins class="diff-new">
Proceed
using
the
previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-new">
processor
state
</ins></a>.</li></ol></li><li id="processing-step-list"><span class="list-number"><ins class="diff-new">
3a.
</ins></span><ins class="diff-new">
Generate
an
RDF
List
by
linking
each
element
of
the
list
using
</ins><code><ins class="diff-new">
rdf:first
</ins></code><ins class="diff-new">
and
</ins><code><ins class="diff-new">
rdf:next
</ins></code>,<ins class="diff-new">
terminating
the
list
with
</ins><code><ins class="diff-new">
rdf:nil
</ins></code><ins class="diff-new">
using
the
following
sequence:
</ins><ol class="algorithm"><li><ins class="diff-new">
If
the
list
has
no
element,
generate
a
triple
using
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
and
</ins><code><ins class="diff-new">
rdf:nil
</ins></code>.</li><li><ins class="diff-new">
Otherwise,
generate
a
triple
using
using
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
and
a
newly
generated
BNode
identified
as
</ins><em><ins class="diff-new">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-1"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em>.</li><li><ins class="diff-new">
For
each
element
other
than
the
last
element
in
the
list:
</ins><ol class="algorithm"><li><ins class="diff-new">
Create
a
processor
state
using
the
active
context,
</ins><em><ins class="diff-new">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-2"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em><ins class="diff-new">
as
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<ins class="diff-new">
and
</ins><code><ins class="diff-new">
rdf:first
</ins></code><ins class="diff-new">
as
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>.</li><li><ins class="diff-new">
Unless
this
is
the
last
element
in
the
list,
generate
a
new
BNode
identified
as
</ins><em><ins class="diff-new">
rest
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-3"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em>,<ins class="diff-new">
otherwise
use
</ins><code><ins class="diff-new">
rdf:nil
</ins></code>.</li><li><ins class="diff-new">
Generate
a
new
triple
using
</ins><em><ins class="diff-new">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-4"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em>,<code><ins class="diff-new">
rdf:rest
</ins></code><ins class="diff-new">
and
</ins><em><ins class="diff-new">
rest
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-5"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em>.</li><li><ins class="diff-new">
Set
</ins><em><ins class="diff-new">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-6"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em><ins class="diff-new">
to
</ins><em><ins class="diff-new">
rest
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-7"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em>.</li></ol></li></ol></li></ol></div></div></div><div class="appendix section" id="markup-examples"><h2><span class="secno"><ins class="diff-new">
B.
</ins></span>
Markup
Examples
</h2>
<p>
The
JSON-LD
markup
examples
below
demonstrate
how
JSON-LD
can
be
used
to
express
semantic
data
marked
up
in
other
languages
such
as
RDFa,
Microformats,
and
Microdata.
These
sections
are
merely
provided
as
proof
that
JSON-LD
is
very
flexible
in
what
it
can
express
across
different
Linked
Data
approaches.
</p>
<div id="rdfa" class="section">
<h3>
<span class="secno">
<del class="diff-old">A.1
</del>
<ins class="diff-chg">B.1
</ins>
</span>
RDFa
</h3>
<p>
The
following
example
describes
three
people
with
their
respective
names
and
homepages.
</p>
<del class="diff-old">&gt;
</del>
<pre class="example">
<ins class="diff-chg">&lt;div <span class="diff">prefix="foaf: http://xmlns.com/foaf/0.1/"</span>&gt;
</ins>
   &lt;ul&gt;
<del class="diff-old">      &lt;li &gt;
        &lt;a &gt;Bob&lt;/a&gt;
</del>
<ins class="diff-chg">      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/bob/" property="foaf:name" </span>&gt;Bob&lt;/a&gt;
</ins>
      &lt;/li&gt;
<del class="diff-old">      &lt;li &gt;
        &lt;a &gt;Eve&lt;/a&gt;
</del>
<ins class="diff-chg">      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/eve/" property="foaf:name" </span>&gt;Eve&lt;/a&gt;
</ins>
      &lt;/li&gt;
<del class="diff-old">      &lt;li &gt;
        &lt;a &gt;Manu&lt;/a&gt;
</del>
<ins class="diff-chg">      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/manu/" property="foaf:name" </span>&gt;Manu&lt;/a&gt;
</ins>
      &lt;/li&gt;
   &lt;/ul&gt;
&lt;/div&gt;
</pre>
<p>
An
example
JSON-LD
implementation
is
described
below,
however,
there
are
other
ways
to
mark-up
this
information
such
that
the
context
is
not
repeated.
</p>
<del class="diff-old">{
  &quot;@context&quot;: { &quot;foaf&quot;: &quot;http://xmlns.com/foaf/0.1/&quot;},
  &quot;@subject&quot;: [
</del>
<pre class="example">
<ins class="diff-chg">{
  "@context": { "foaf": "http://xmlns.com/foaf/0.1/"},
  "@subject": [
</ins>
   {
<del class="diff-old">     &quot;@subject&quot;: &quot;_:bnode1&quot;,
     &quot;@type&quot;: &quot;foaf:Person&quot;,
     &quot;foaf:homepage&quot;: &quot;http://example.com/bob/&quot;,
     &quot;foaf:name&quot;: &quot;Bob&quot;
</del>
<ins class="diff-chg">     "@subject": "_:bnode1",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/bob/",
     "foaf:name": "Bob"
</ins>
   },
   {
<del class="diff-old">     &quot;@subject&quot;: &quot;_:bnode2&quot;,
     &quot;@type&quot;: &quot;foaf:Person&quot;,
     &quot;foaf:homepage&quot;: &quot;http://example.com/eve/&quot;,
     &quot;foaf:name&quot;: &quot;Eve&quot;
</del>
<ins class="diff-chg">     "@subject": "_:bnode2",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/eve/",
     "foaf:name": "Eve"
</ins>
   },
   {
<del class="diff-old">     &quot;@subject&quot;: &quot;_:bnode3&quot;,
     &quot;@type&quot;: &quot;foaf:Person&quot;,
     &quot;foaf:homepage&quot;: &quot;http://example.com/manu/&quot;,
     &quot;foaf:name&quot;: &quot;Manu&quot;
</del>
<ins class="diff-chg">     "@subject": "_:bnode3",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/manu/",
     "foaf:name": "Manu"
</ins>
   }
  ]
}
</pre>
</div>
<div id="microformats" class="section">
<h3>
<span class="secno">
<del class="diff-old">A.2
</del>
<ins class="diff-chg">B.2
</ins>
</span>
Microformats
</h3>
<p>
The
following
example
uses
a
simple
Microformats
hCard
example
to
express
how
the
Microformat
is
represented
in
JSON-LD.
</p>
<del class="diff-old">&lt;div class=&quot;vcard&quot;&gt;
 &lt;a class=&quot;url fn&quot; href=&quot;http://tantek.com/&quot;&gt;Tantek Çelik&lt;/a&gt;
</del>
<pre class="example">
<ins class="diff-chg">&lt;div class="vcard"&gt;
 &lt;a class="url fn" href="http://tantek.com/"&gt;Tantek Çelik&lt;/a&gt;
</ins>
&lt;/div&gt;
</pre>
<p>
The
representation
of
the
hCard
expresses
the
Microformat
terms
in
the
context
and
uses
them
directly
for
the
<code>
url
</code>
and
<code>
fn
</code>
properties.
Also
note
that
the
Microformat
to
JSON-LD
processor
has
generated
the
proper
URL
type
for
<code>
http://tantek.com
</code>.
</p>
<del class="diff-old">{
  &quot;@context&quot;:
</del>
<pre class="example">
<ins class="diff-chg">{
  "@context":
</ins>
  {
<del class="diff-old">    &quot;vcard&quot;: &quot;http://microformats.org/profile/hcard#vcard&quot;,
    &quot;url&quot;: &quot;http://microformats.org/profile/hcard#url&quot;,
    &quot;fn&quot;: &quot;http://microformats.org/profile/hcard#fn&quot;,
    &quot;@coerce&quot;: { &quot;@iri&quot;: &quot;url&quot; }
</del>
<ins class="diff-chg">    "vcard": "http://microformats.org/profile/hcard#vcard",
    "url": "http://microformats.org/profile/hcard#url",
    "fn": "http://microformats.org/profile/hcard#fn",
    "@coerce": { "@iri": "url" }
</ins>
  },
<del class="diff-old">  &quot;@subject&quot;: &quot;_:bnode1&quot;,
  &quot;@type&quot;: &quot;vcard&quot;,
  &quot;url&quot;: &quot;http://tantek.com/&quot;,
  &quot;fn&quot;: &quot;Tantek Çelik&quot;
</del>
<ins class="diff-chg">  "@subject": "_:bnode1",
  "@type": "vcard",
  "url": "http://tantek.com/",
  "fn": "Tantek Çelik"
</ins>
}
</pre>
</div>
<div id="microdata" class="section">
<h3>
<span class="secno">
<del class="diff-old">A.3
</del>
<ins class="diff-chg">B.3
</ins>
</span>
Microdata
</h3>
<p>
The
Microdata
example
below
expresses
book
information
as
a
Microdata
Work
item.
</p>
<del class="diff-old">&lt;dl itemscope
    itemtype=&quot;http://purl.org/vocab/frbr/core#Work&quot;
    itemid=&quot;http://purl.oreilly.com/works/45U8QJGZSQKDH8N&quot;&gt;
</del>
<pre class="example">
<ins class="diff-chg">&lt;dl itemscope
    itemtype="http://purl.org/vocab/frbr/core#Work"
    itemid="http://purl.oreilly.com/works/45U8QJGZSQKDH8N"&gt;
</ins>
 &lt;dt&gt;Title&lt;/dt&gt;
<del class="diff-old"> &lt;dd&gt;&lt;cite itemprop=&quot;http://purl.org/dc/terms/title&quot;&gt;Just a Geek&lt;/cite&gt;&lt;/dd&gt;
</del>
<ins class="diff-chg"> &lt;dd&gt;&lt;cite itemprop="http://purl.org/dc/terms/title"&gt;Just a Geek&lt;/cite&gt;&lt;/dd&gt;
</ins>
 &lt;dt&gt;By&lt;/dt&gt;
<del class="diff-old"> &lt;dd&gt;&lt;span itemprop=&quot;http://purl.org/dc/terms/creator&quot;&gt;Wil Wheaton&lt;/span&gt;&lt;/dd&gt;
</del>
<ins class="diff-chg"> &lt;dd&gt;&lt;span itemprop="http://purl.org/dc/terms/creator"&gt;Wil Wheaton&lt;/span&gt;&lt;/dd&gt;
</ins>
 &lt;dt&gt;Format&lt;/dt&gt;
<del class="diff-old"> &lt;dd itemprop=&quot;http://purl.org/vocab/frbr/core#realization&quot;
</del>
<ins class="diff-chg"> &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
</ins>
     itemscope
<del class="diff-old">     itemtype=&quot;http://purl.org/vocab/frbr/core#Expression&quot;
     itemid=&quot;http://purl.oreilly.com/products/9780596007683.BOOK&quot;&gt;
  &lt;link itemprop=&quot;http://purl.org/dc/terms/type&quot; href=&quot;http://purl.oreilly.com/product-types/BOOK&quot;&gt;
</del>
<ins class="diff-chg">     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596007683.BOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/BOOK"&gt;
</ins>
  Print
 &lt;/dd&gt;
<del class="diff-old"> &lt;dd itemprop=&quot;http://purl.org/vocab/frbr/core#realization&quot;
</del>
<ins class="diff-chg"> &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
</ins>
     itemscope
<del class="diff-old">     itemtype=&quot;http://purl.org/vocab/frbr/core#Expression&quot;
     itemid=&quot;http://purl.oreilly.com/products/9780596802189.EBOOK&quot;&gt;
  &lt;link itemprop=&quot;http://purl.org/dc/terms/type&quot; href=&quot;http://purl.oreilly.com/product-types/EBOOK&quot;&gt;
</del>
<ins class="diff-chg">     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596802189.EBOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/EBOOK"&gt;
</ins>
  Ebook
 &lt;/dd&gt;
&lt;/dl&gt;
</pre>
<p>
Note
that
the
JSON-LD
representation
of
the
Microdata
information
stays
true
to
the
desires
of
the
Microdata
community
to
avoid
contexts
and
instead
refer
to
items
by
their
full
IRI.
</p>
<del class="diff-old">[
</del>
<pre class="example">
<ins class="diff-chg">[
</ins>
  {
<del class="diff-old">    &quot;@subject&quot;: &quot;http://purl.oreilly.com/works/45U8QJGZSQKDH8N&quot;,
    &quot;@type&quot;: &quot;http://purl.org/vocab/frbr/core#Work&quot;,
    &quot;http://purl.org/dc/terms/title&quot;: &quot;Just a Geek&quot;,
    &quot;http://purl.org/dc/terms/creator&quot;: &quot;Whil Wheaton&quot;,
    &quot;http://purl.org/vocab/frbr/core#realization&quot;:
      [&quot;http://purl.oreilly.com/products/9780596007683.BOOK&quot;, &quot;http://purl.oreilly.com/products/9780596802189.EBOOK&quot;]
</del>
<ins class="diff-chg">    "@subject": "http://purl.oreilly.com/works/45U8QJGZSQKDH8N",
    "@type": "http://purl.org/vocab/frbr/core#Work",
    "http://purl.org/dc/terms/title": "Just a Geek",
    "http://purl.org/dc/terms/creator": "Whil Wheaton",
    "http://purl.org/vocab/frbr/core#realization":
      ["http://purl.oreilly.com/products/9780596007683.BOOK", "http://purl.oreilly.com/products/9780596802189.EBOOK"]
</ins>
  },
  {
<del class="diff-old">    &quot;@subject&quot;: &quot;http://purl.oreilly.com/products/9780596007683.BOOK&quot;,
    &quot;@type&quot;: &quot;http://purl.org/vocab/frbr/core#Expression&quot;,
    &quot;http://purl.org/dc/terms/type&quot;: &quot;http://purl.oreilly.com/product-types/BOOK&quot;
</del>
<ins class="diff-chg">    "@subject": "http://purl.oreilly.com/products/9780596007683.BOOK",
    "@type": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/BOOK"
</ins>
  },
  {
<del class="diff-old">    &quot;@subject&quot;: &quot;http://purl.oreilly.com/products/9780596802189.EBOOK&quot;,
    &quot;@type&quot;: &quot;http://purl.org/vocab/frbr/core#Expression&quot;,
    &quot;http://purl.org/dc/terms/type&quot;: &quot;http://purl.oreilly.com/product-types/EBOOK&quot;
</del>
<ins class="diff-chg">    "@subject": "http://purl.oreilly.com/products/9780596802189.EBOOK",
    "@type": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/EBOOK"
</ins>
  }
]
</pre>
</div>
</div>
<div class="appendix section" id="mashing-up-vocabularies">
<h2>
<span class="secno">
<del class="diff-old">B.
</del>
<ins class="diff-chg">C.
</ins>
</span>
Mashing
Up
Vocabularies
</h2>
<p>
Developers
would
also
benefit
by
allowing
other
vocabularies
to
be
used
automatically
with
their
JSON
API.
There
are
over
200
<a class="tref internalDFN" title="Web_Vocabulary" href="#dfn-web_vocabulary">
Web
Vocabulary
</a>
Documents
that
are
available
for
use
on
the
Web
today.
Some
of
these
vocabularies
are:
</p>
<ul>
<li>
RDF
-
for
describing
information
about
objects
and
concepts
on
the
Web.
</li>
<li>
RDFS
-
for
expressing
things
like
labels
and
comments.
</li>
<li>
XSD
-
for
specifying
basic
types
like
strings,
integers,
dates
and
times.
</li>
<li>
Dublin
Core
-
for
describing
creative
works.
</li>
<li>
FOAF
-
for
describing
social
networks.
</li>
<li>
Calendar
-
for
specifying
events.
</li>
<li>
SIOC
-
for
describing
discussions
on
blogs
and
websites.
</li>
<li>
CCrel
-
for
describing
Creative
Commons
and
other
types
of
licenses.
</li>
<li>
GEO
-
for
describing
geographic
location.
</li>
<li>
VCard
-
for
describing
organizations
and
people.
</li>
<li>
DOAP
-
for
describing
projects.
</li>
</ul>
<p>
You
can
use
these
vocabularies
in
combination,
like
so:
</p>
<del class="diff-old">{
  &quot;&quot;,
  &quot;&quot;: &quot;Manu Sporny&quot;,
  &quot;&quot;: &quot;http://manu.sporny.org/&quot;,
  &quot;&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
  "<span class="diff">@type</span>": "<span class="diff">foaf:Person</span>",
  "<span class="diff">foaf:name</span>": "Manu Sporny",
  "<span class="diff">foaf:homepage</span>": "http://manu.sporny.org/",
  "<span class="diff">sioc:avatar</span>": "http://twitter.com/account/profile_image/manusporny"
</ins>
}
</pre>
<p>
Developers
can
also
specify
their
own
Vocabulary
documents
by
modifying
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
in-line
using
the
<code>
@context
</code>
keyword,
like
so:
</p>
<del class="diff-old">{
  ,
  &quot;@type&quot;: &quot;foaf:Person&quot;,
  &quot;foaf:name&quot;: &quot;Manu Sporny&quot;,
  &quot;foaf:homepage&quot;: &quot;http://manu.sporny.org/&quot;,
  &quot;sioc:avatar&quot;: &quot;http://twitter.com/account/profile_image/manusporny&quot;,
  &quot;myvocab:personality&quot;: &quot;friendly&quot;
</del>
<pre class="example">
<ins class="diff-chg">{
</ins>  <span class="diff">"@context": { "myvocab": "http://example.org/myvocab#" }</span>,<ins class="diff-chg">
  "@type": "foaf:Person",
  "foaf:name": "Manu Sporny",
  "foaf:homepage": "http://manu.sporny.org/",
  "sioc:avatar": "http://twitter.com/account/profile_image/manusporny"<span class="diff">,
  "myvocab:personality": "friendly"</span>
</ins>
}
</pre>
<p>
The
<code>
@context
</code>
keyword
is
used
to
change
how
the
JSON-LD
processor
evaluates
key-value
pairs.
In
this
case,
it
was
used
to
map
one
string
('myvocab')
to
another
string,
which
is
interpreted
as
a
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>.
In
the
example
above,
the
<code>
myvocab
</code>
string
is
replaced
with
<del class="diff-old">&quot;
</del>
<ins class="diff-chg">"
</ins>
<code>
http://example.org/myvocab#
</code>
<del class="diff-old">&quot;
</del>
<ins class="diff-chg">"
</ins>
when
it
is
detected.
In
the
example
above,
<del class="diff-old">&quot;
</del>
<ins class="diff-chg">"
</ins>
<code>
myvocab:personality
</code>
<del class="diff-old">&quot;
</del>
<ins class="diff-chg">"
</ins>
would
expand
to
<del class="diff-old">&quot;
</del>
<ins class="diff-chg">"
</ins>
<code>
http://example.org/myvocab#personality
</code>
<del class="diff-old">&quot;.
</del>
<ins class="diff-chg">".
</ins>
</p>
<p>
This
mechanism
is
a
short-hand,
called
a
<a class="tref internalDFN" title="Web_Vocabulary" href="#dfn-web_vocabulary">
Web
Vocabulary
</a>
<a class="tref internalDFN" title="prefix" href="#dfn-prefix-1">
prefix
</a>,
and
provides
developers
an
unambiguous
way
to
map
any
JSON
value
to
RDF.
</p>
<p>
</p>
</div>
<div class="appendix section" id="iana-considerations">
<h2>
<span class="secno">
<del class="diff-old">C.
</del>
<ins class="diff-chg">D.
</ins>
</span>
IANA
Considerations
</h2>
<p>
This
section
is
included
merely
for
standards
community
review
and
will
be
submitted
to
the
Internet
Engineering
Steering
Group
if
this
specification
becomes
a
W3C
Recommendation.
</p>
<dl>
<dt>
Type
name:
</dt>
<dd>
application
</dd>
<dt>
Subtype
name:
</dt>
<dd>
ld+json
</dd>
<dt>
Required
parameters:
</dt>
<dd>
None
</dd>
<dt>
Optional
parameters:
</dt>
<dd>
<dl>
<dt>
<code>
form
</code>
</dt>
<dd>
Determines
the
serialization
form
for
the
JSON-LD
document.
Valid
values
include;
<code>
compacted
</code>,
<code>
expanded
</code>,
<code>
framed
</code>,
and
<code>
normalized
</code>.
Other
values
are
allowed,
but
must
be
pre-pended
with
a
<code>
x-
</code>
string
until
they
are
clearly
defined
by
a
stable
specification.
If
no
form
is
specified
in
an
HTTP
request
header
to
a
responding
application,
such
as
a
Web
server,
the
application
<em class="rfc2119" title="may">
may
</em>
choose
any
form.
If
no
form
is
specified
for
a
receiving
application,
the
form
<em class="rfc2119" title="must not">
must
not
</em>
be
assumed
to
take
any
particular
form.
</dd>
<div class="issue">
It
is
currently
<a href="https://github.com/json-ld/json-ld.org/issues/14">
being
discussed
to
remove
form=framed
</a>
from
this
specification
as
there
are
several
issues
with
it.
</div>
</dl>
</dd>
<dt>
Encoding
considerations:
</dt>
<dd>
The
same
as
the
<code>
application/json
</code>
MIME
media
type.
</dd>
<dt>
Security
considerations:
</dt>
<dd>
Since
JSON-LD
is
intended
to
be
a
pure
data
exchange
format
for
directed
graphs,
the
serialization
<em class="rfc2119" title="should not">
should
not
</em>
be
passed
through
a
code
execution
mechanism
such
as
JavaScript's
<code>
eval()
</code>
function.
It
is
<em class="rfc2119" title="recommended">
recommended
</em>
that
a
conforming
parser
does
not
attempt
to
directly
evaluate
the
JSON-LD
serialization
and
instead
purely
parse
the
input
into
a
language-native
data
structure.
</dd>
<dt>
Interoperability
considerations:
</dt>
<dd>
Not
Applicable
</dd>
<dt>
Published
specification:
</dt>
<dd>
The
<a href="http://json-ld/spec/latest/">
JSON-LD
</a>
specification.
</dd>
<dt>
Applications
that
use
this
media
type:
</dt>
<dd>
Any
programming
environment
that
requires
the
exchange
of
directed
graphs.
Implementations
of
JSON-LD
have
been
created
for
JavaScript,
Python,
Ruby,
PHP
and
C++.
</dd>
<dt>
Additional
information:
</dt>
<dd>
<dl>
<dt>
Magic
number(s):
</dt>
<dd>
Not
Applicable
</dd>
<dt>
File
extension(s):
</dt>
<dd>.jsonld
</dd>
<dt>
Macintosh
file
type
code(s):
</dt>
<dd>
TEXT
</dd>
</dl>
</dd>
<dt>
Person
<del class="diff-old">&amp;
</del>
<ins class="diff-chg">&
</ins>
email
address
to
contact
for
further
information:
</dt>
<dd>
Manu
Sporny
<del class="diff-old">&lt;msporny@digitalbazaar.com&gt;
</del>
<msporny@digitalbazaar.com>
</dd>
<dt>
Intended
usage:
</dt>
<dd>
Common
</dd>
<dt>
Restrictions
on
usage:
</dt>
<dd>
None
</dd>
<dt>
Author(s):
</dt>
<dd>
Manu
Sporny,
Gregg
Kellogg,
Dave
Longley
</dd>
<dt>
Change
controller:
</dt>
<dd>
W3C
</dd>
</dl>
</div>
<div class="appendix section" id="acknowledgements">
<h2>
<span class="secno">
<del class="diff-old">D.
</del>
<ins class="diff-chg">E.
</ins>
</span>
Acknowledgements
</h2>
<p>
The
editors
would
like
to
thank
Mark
Birbeck,
who
provided
a
great
deal
of
the
initial
push
behind
the
JSON-LD
work
via
his
work
on
RDFj,
Dave
Longley,
Dave
Lehn
and
Mike
Johnson
who
reviewed,
provided
feedback,
and
performed
several
implementations
of
the
specification,
and
Ian
Davis,
who
created
RDF/JSON.
Thanks
also
to
Nathan
Rixham,
Bradley
P.
Allen,
Kingsley
Idehen,
Glenn
McDonald,
Alexandre
Passant,
Danny
Ayers,
Ted
Thibodeau
Jr.,
Olivier
Grisel,
Niklas
Lindström,
Markus
Lanthaler,
and
Richard
Cyganiak
for
their
input
on
the
specification.
Another
huge
thank
you
goes
out
to
Dave
Longley
who
designed
many
of
the
algorithms
used
in
this
specification,
including
the
normalization
algorithm
which
was
a
monumentally
difficult
design
challenge.
</p>
</div>
<div id="references" class="appendix section">
<h2>
<span class="secno">
<del class="diff-old">E.
</del>
<ins class="diff-chg">F.
</ins>
</span>
References
</h2>
<div id="normative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">E.1
</del>
<ins class="diff-chg">F.1
</ins>
</span>
Normative
references
</h3>
<dl class="bibliography">
<dt id="bib-BCP47">
[BCP47]
</dt>
<dd>
A.
Phillips,
M.
Davis.
<a href="http://tools.ietf.org/rfc/bcp/bcp47.txt">
<cite>
Tags
for
Identifying
Languages
</cite>
</a>
September
2009.
IETF
Best
Current
Practice.
URL:
<a href="http://tools.ietf.org/rfc/bcp/bcp47.txt">
http://tools.ietf.org/rfc/bcp/bcp47.txt
</a>
</dd>
<dt id="bib-RDF-CONCEPTS">
[RDF-CONCEPTS]
</dt>
<dd>
Graham
Klyne;
Jeremy
J.
Carroll.
<a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">
<cite>
Resource
Description
Framework
(RDF):
Concepts
and
Abstract
Syntax.
</cite>
</a>
10
February
2004.
W3C
Recommendation.
URL:
<a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">
http://www.w3.org/TR/2004/REC-rdf-concepts-20040210
</a>
</dd>
<dt id="bib-RFC3986">
<ins class="diff-new">[RFC3986]
</ins></dt><dd><ins class="diff-new">
T.
Berners-Lee;
R.
Fielding;
L.
Masinter.
</ins><a href="http://www.ietf.org/rfc/rfc3986.txt"><cite><ins class="diff-new">
Uniform
Resource
Identifier
(URI):
Generic
Syntax.
</ins></cite></a><ins class="diff-new">
January
2005.
Internet
RFC
3986.
URL:
</ins><a href="http://www.ietf.org/rfc/rfc3986.txt"><ins class="diff-new">
http://www.ietf.org/rfc/rfc3986.txt
</ins></a></dd>
<dt id="bib-RFC3987">
[RFC3987]
</dt>
<dd>
M.
Dürst;
M.
Suignard.
<a href="http://www.ietf.org/rfc/rfc3987.txt">
<cite>
Internationalized
Resource
Identifiers
(IRIs).
</cite>
</a>
January
2005.
Internet
RFC
3987.
URL:
<a href="http://www.ietf.org/rfc/rfc3987.txt">
http://www.ietf.org/rfc/rfc3987.txt
</a>
</dd>
<dt id="bib-RFC4627">
[RFC4627]
</dt>
<dd>
D.
Crockford.
<a href="http://www.ietf.org/rfc/rfc4627.txt">
<cite>
The
application/json
Media
Type
for
JavaScript
Object
Notation
(JSON)
</cite>
</a>
July
2006.
Internet
RFC
4627.
URL:
<a href="http://www.ietf.org/rfc/rfc4627.txt">
http://www.ietf.org/rfc/rfc4627.txt
</a>
</dd>
<dt id="bib-WEBIDL">
[WEBIDL]
</dt>
<dd>
Cameron
McCormack.
<a href="http://www.w3.org/TR/2008/WD-WebIDL-20081219">
<cite>
Web
IDL.
</cite>
</a>
19
December
2008.
W3C
Working
Draft.
(Work
in
progress.)
URL:
<a href="http://www.w3.org/TR/2008/WD-WebIDL-20081219">
http://www.w3.org/TR/2008/WD-WebIDL-20081219
</a>
</dd>
</dl>
</div>
<div id="informative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">E.2
</del>
<ins class="diff-chg">F.2
</ins>
</span>
Informative
references
</h3>
<dl class="bibliography">
<dt id="bib-ECMA-262">
[ECMA-262]
</dt>
<dd>
<a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">
<cite>
ECMAScript
Language
Specification,
Third
Edition.
</cite>
</a>
December
1999.
URL:
<a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">
http://www.ecma-international.org/publications/standards/Ecma-262.htm
</a>
</dd>
<del class="diff-old">[HTML-RDFA]
Manu
Sporny;
et
al.
HTML+RDFa
04
March
2010.
W3C
Working
Draft.
URL:
http://www.w3.org/TR/rdfa-in-html/
</del>
<dt id="bib-MICRODATA">
[MICRODATA]
</dt>
<dd>
Ian
Hickson;
et
al.
<a href="http://www.w3.org/TR/microdata/">
<cite>
Microdata
</cite>
</a>
04
March
2010.
W3C
Working
Draft.
URL:
<a href="http://www.w3.org/TR/microdata/">
http://www.w3.org/TR/microdata/
</a>
</dd>
<dt id="bib-MICROFORMATS">
[MICROFORMATS]
</dt>
<dd>
<a href="http://microformats.org">
<cite>
Microformats
</cite>
</a>.
URL:
<a href="http://microformats.org">
http://microformats.org
</a>
</dd>
<dt id="bib-RDF-SCHEMA">
<ins class="diff-new">[RDF-SCHEMA]
</ins></dt><dd><ins class="diff-new">
Dan
Brickley;
Ramanathan
V.
Guha.
</ins><a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><cite><ins class="diff-new">
RDF
Vocabulary
Description
Language
1.0:
RDF
Schema.
</ins></cite></a><ins class="diff-new">
10
February
2004.
W3C
Recommendation.
URL:
</ins><a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><ins class="diff-new">
http://www.w3.org/TR/2004/REC-rdf-schema-20040210
</ins></a></dd>
<dt id="bib-RDFA-CORE">
[RDFA-CORE]
</dt>
<dd>
Shane
McCarron;
et
al.
<a href="http://www.w3.org/TR/2011/WD-rdfa-core-20110331">
<cite>
RDFa
Core
1.1:
Syntax
and
processing
rules
for
embedding
RDF
through
attributes.
</cite>
</a>
31
March
2011.
W3C
Working
Draft.
URL:
<a href="http://www.w3.org/TR/2011/WD-rdfa-core-20110331">
http://www.w3.org/TR/2011/WD-rdfa-core-20110331
</a>
</dd>
<dt id="bib-TURTLE">
<ins class="diff-new">[TURTLE]
</ins></dt><dd><ins class="diff-new">
David
Beckett,
Tim
Berners-Lee.
</ins><a href="http://www.w3.org/TeamSubmission/turtle/"><cite><ins class="diff-new">
Turtle:
Terse
RDF
Triple
Language.
</ins></cite></a><ins class="diff-new">
January
2008.
W3C
Team
Submission.
URL:
</ins><a href="http://www.w3.org/TeamSubmission/turtle/"><ins class="diff-new">
http://www.w3.org/TeamSubmission/turtle/
</ins>
</a>
</dd>
</dl>
</div>
</div>
</body>
</html>
